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