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 #include "linklist.h"
  28 #include "bgpd.h"
  29 #include "bgp_advertise.h"
  30
  31 struct bgp_table {
  32         /* table belongs to this instance */
  33         struct bgp *bgp;
  34
  35         /* afi/safi of this table */
  36         afi_t afi;
  37         safi_t safi;
  38
  39         int lock;
  40
  41         struct route_table *route_table;
  42         uint64_t version;
  43 };
  44
  45 struct bgp_node {
  46         /*
  47          * CAUTION
  48          *
  49          * These fields must be the very first fields in this structure.
  50          *
  51          * @see bgp_node_to_rnode
  52          * @see bgp_node_from_rnode
  53          */
  54         ROUTE_NODE_FIELDS
  55
  56         struct bgp_adj_out_rb adj_out;
  57
  58         struct bgp_adj_in *adj_in;
  59
  60         struct bgp_node *prn;
  61
  62         STAILQ_ENTRY(bgp_node) pq;
  63
  64         uint64_t version;
  65
  66         mpls_label_t local_label;
  67
  68         uint8_t flags;
  69 #define BGP_NODE_PROCESS_SCHEDULED      (1 << 0)
  70 #define BGP_NODE_USER_CLEAR             (1 << 1)
  71 #define BGP_NODE_LABEL_CHANGED          (1 << 2)
  72 #define BGP_NODE_REGISTERED_FOR_LABEL   (1 << 3)
  73
  74         struct bgp_addpath_node_data tx_addpath;
  75 };
  76
  77 /*
  78  * bgp_table_iter_t
  79  *
  80  * Structure that holds state for iterating over a bgp table.
  81  */
  82 typedef struct bgp_table_iter_t_ {
  83         struct bgp_table *table;
  84         route_table_iter_t rt_iter;
  85 } bgp_table_iter_t;
  86
  87 extern struct bgp_table *bgp_table_init(struct bgp *bgp, afi_t, safi_t);
  88 extern void bgp_table_lock(struct bgp_table *);
  89 extern void bgp_table_unlock(struct bgp_table *);
  90 extern void bgp_table_finish(struct bgp_table **);
  91
  92
  93 /*
  94  * bgp_node_from_rnode
  95  *
  96  * Returns the bgp_node structure corresponding to a route_node.
  97  */
  98 static inline struct bgp_node *bgp_node_from_rnode(struct route_node *rnode)
  99 {
 100         return (struct bgp_node *)rnode;
 101 }
 102
 103 /*
 104  * bgp_node_to_rnode
 105  *
 106  * Returns the route_node structure corresponding to a bgp_node.
 107  */
 108 static inline struct route_node *bgp_node_to_rnode(struct bgp_node *node)
 109 {
 110         return (struct route_node *)node;
 111 }
 112
 113 /*
 114  * bgp_node_table
 115  *
 116  * Returns the bgp_table that the given node is in.
 117  */
 118 static inline struct bgp_table *bgp_node_table(struct bgp_node *node)
 119 {
 120         return route_table_get_info(bgp_node_to_rnode(node)->table);
 121 }
 122
 123 /*
 124  * bgp_node_parent_nolock
 125  *
 126  * Gets the parent node of the given node without locking it.
 127  */
 128 static inline struct bgp_node *bgp_node_parent_nolock(struct bgp_node *node)
 129 {
 130         return bgp_node_from_rnode(node->parent);
 131 }
 132
 133 /*
 134  * bgp_unlock_node
 135  */
 136 static inline void bgp_unlock_node(struct bgp_node *node)
 137 {
 138         route_unlock_node(bgp_node_to_rnode(node));
 139 }
 140
 141 /*
 142  * bgp_table_top_nolock
 143  *
 144  * Gets the top node in the table without locking it.
 145  *
 146  * @see bgp_table_top
 147  */
 148 static inline struct bgp_node *
 149 bgp_table_top_nolock(const struct bgp_table *const table)
 150 {
 151         return bgp_node_from_rnode(table->route_table->top);
 152 }
 153
 154 /*
 155  * bgp_table_top
 156  */
 157 static inline struct bgp_node *
 158 bgp_table_top(const struct bgp_table *const table)
 159 {
 160         return bgp_node_from_rnode(route_top(table->route_table));
 161 }
 162
 163 /*
 164  * bgp_route_next
 165  */
 166 static inline struct bgp_node *bgp_route_next(struct bgp_node *node)
 167 {
 168         return bgp_node_from_rnode(route_next(bgp_node_to_rnode(node)));
 169 }
 170
 171 /*
 172  * bgp_route_next_until
 173  */
 174 static inline struct bgp_node *bgp_route_next_until(struct bgp_node *node,
 175                                                     struct bgp_node *limit)
 176 {
 177         struct route_node *rnode;
 178
 179         rnode = route_next_until(bgp_node_to_rnode(node),
 180                                  bgp_node_to_rnode(limit));
 181         return bgp_node_from_rnode(rnode);
 182 }
 183
 184 /*
 185  * bgp_node_get
 186  */
 187 static inline struct bgp_node *bgp_node_get(struct bgp_table *const table,
 188                                             struct prefix *p)
 189 {
 190         return bgp_node_from_rnode(route_node_get(table->route_table, p));
 191 }
 192
 193 /*
 194  * bgp_node_lookup
 195  */
 196 static inline struct bgp_node *
 197 bgp_node_lookup(const struct bgp_table *const table, struct prefix *p)
 198 {
 199         return bgp_node_from_rnode(route_node_lookup(table->route_table, p));
 200 }
 201
 202 /*
 203  * bgp_lock_node
 204  */
 205 static inline struct bgp_node *bgp_lock_node(struct bgp_node *node)
 206 {
 207         return bgp_node_from_rnode(route_lock_node(bgp_node_to_rnode(node)));
 208 }
 209
 210 /*
 211  * bgp_node_match
 212  */
 213 static inline struct bgp_node *bgp_node_match(const struct bgp_table *table,
 214                                               struct prefix *p)
 215 {
 216         return bgp_node_from_rnode(route_node_match(table->route_table, p));
 217 }
 218
 219 /*
 220  * bgp_node_match_ipv4
 221  */
 222 static inline struct bgp_node *
 223 bgp_node_match_ipv4(const struct bgp_table *table, struct in_addr *addr)
 224 {
 225         return bgp_node_from_rnode(
 226                 route_node_match_ipv4(table->route_table, addr));
 227 }
 228
 229 /*
 230  * bgp_node_match_ipv6
 231  */
 232 static inline struct bgp_node *
 233 bgp_node_match_ipv6(const struct bgp_table *table, struct in6_addr *addr)
 234 {
 235         return bgp_node_from_rnode(
 236                 route_node_match_ipv6(table->route_table, addr));
 237 }
 238
 239 static inline unsigned long bgp_table_count(const struct bgp_table *const table)
 240 {
 241         return route_table_count(table->route_table);
 242 }
 243
 244 /*
 245  * bgp_table_get_next
 246  */
 247 static inline struct bgp_node *bgp_table_get_next(const struct bgp_table *table,
 248                                                   struct prefix *p)
 249 {
 250         return bgp_node_from_rnode(route_table_get_next(table->route_table, p));
 251 }
 252
 253 /*
 254  * bgp_table_iter_init
 255  */
 256 static inline void bgp_table_iter_init(bgp_table_iter_t *iter,
 257                                        struct bgp_table *table)
 258 {
 259         bgp_table_lock(table);
 260         iter->table = table;
 261         route_table_iter_init(&iter->rt_iter, table->route_table);
 262 }
 263
 264 /*
 265  * bgp_table_iter_next
 266  */
 267 static inline struct bgp_node *bgp_table_iter_next(bgp_table_iter_t *iter)
 268 {
 269         return bgp_node_from_rnode(route_table_iter_next(&iter->rt_iter));
 270 }
 271
 272 /*
 273  * bgp_table_iter_cleanup
 274  */
 275 static inline void bgp_table_iter_cleanup(bgp_table_iter_t *iter)
 276 {
 277         route_table_iter_cleanup(&iter->rt_iter);
 278         bgp_table_unlock(iter->table);
 279         iter->table = NULL;
 280 }
 281
 282 /*
 283  * bgp_table_iter_pause
 284  */
 285 static inline void bgp_table_iter_pause(bgp_table_iter_t *iter)
 286 {
 287         route_table_iter_pause(&iter->rt_iter);
 288 }
 289
 290 /*
 291  * bgp_table_iter_is_done
 292  */
 293 static inline int bgp_table_iter_is_done(bgp_table_iter_t *iter)
 294 {
 295         return route_table_iter_is_done(&iter->rt_iter);
 296 }
 297
 298 /*
 299  * bgp_table_iter_started
 300  */
 301 static inline int bgp_table_iter_started(bgp_table_iter_t *iter)
 302 {
 303         return route_table_iter_started(&iter->rt_iter);
 304 }
 305
 306 /* This would benefit from a real atomic operation...
 307  * until then. */
 308 static inline uint64_t bgp_table_next_version(struct bgp_table *table)
 309 {
 310         return ++table->version;
 311 }
 312
 313 static inline uint64_t bgp_table_version(struct bgp_table *table)
 314 {
 315         return table->version;
 316 }
 317
 318 void bgp_table_range_lookup(const struct bgp_table *table, struct prefix *p,
 319                             uint8_t maxlen, struct list *matches);
 320
 321
 322 static inline struct bgp_aggregate *
 323 bgp_node_get_bgp_aggregate_info(struct bgp_node *node)
 324 {
 325         return node->info;
 326 }
 327
 328 static inline void
 329 bgp_node_set_bgp_aggregate_info(struct bgp_node *node,
 330                                 struct bgp_aggregate *aggregate)
 331 {
 332         node->info = aggregate;
 333 }
 334
 335 static inline struct bgp_distance *
 336 bgp_node_get_bgp_distance_info(struct bgp_node *node)
 337 {
 338         return node->info;
 339 }
 340
 341 static inline void bgp_node_set_bgp_distance_info(struct bgp_node *node,
 342                                                   struct bgp_distance *distance)
 343 {
 344         node->info = distance;
 345 }
 346
 347 static inline struct bgp_static *
 348 bgp_node_get_bgp_static_info(struct bgp_node *node)
 349 {
 350         return node->info;
 351 }
 352
 353 static inline void bgp_node_set_bgp_static_info(struct bgp_node *node,
 354                                                 struct bgp_static *bgp_static)
 355 {
 356         node->info = bgp_static;
 357 }
 358
 359 static inline struct bgp_connected_ref *
 360 bgp_node_get_bgp_connected_ref_info(struct bgp_node *node)
 361 {
 362         return node->info;
 363 }
 364
 365 static inline void
 366 bgp_node_set_bgp_connected_ref_info(struct bgp_node *node,
 367                                     struct bgp_connected_ref *bc)
 368 {
 369         node->info = bc;
 370 }
 371
 372 static inline struct bgp_nexthop_cache *
 373 bgp_node_get_bgp_nexthop_info(struct bgp_node *node)
 374 {
 375         return node->info;
 376 }
 377
 378 static inline void bgp_node_set_bgp_nexthop_info(struct bgp_node *node,
 379                                              struct bgp_nexthop_cache *bnc)
 380 {
 381         node->info = bnc;
 382 }
 383
 384 static inline struct bgp_path_info *
 385 bgp_node_get_bgp_path_info(struct bgp_node *node)
 386 {
 387         return node->info;
 388 }
 389
 390 static inline void bgp_node_set_bgp_path_info(struct bgp_node *node,
 391                                               struct bgp_path_info *bi)
 392 {
 393         node->info = bi;
 394 }
 395
 396 static inline struct bgp_table *
 397 bgp_node_get_bgp_table_info(struct bgp_node *node)
 398 {
 399         return node->info;
 400 }
 401
 402 static inline void bgp_node_set_bgp_table_info(struct bgp_node *node,
 403                                                struct bgp_table *table)
 404 {
 405         node->info = table;
 406 }
 407
 408 static inline bool bgp_node_has_bgp_path_info_data(struct bgp_node *node)
 409 {
 410         return !!node->info;
 411 }
 412
 413 #endif /* _QUAGGA_BGP_TABLE_H */