Annotation of embedaddon/bird2/nest/route.h, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD Internet Routing Daemon -- Routing Table
! 3: *
! 4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
! 5: *
! 6: * Can be freely distributed and used under the terms of the GNU GPL.
! 7: */
! 8:
! 9: #ifndef _BIRD_ROUTE_H_
! 10: #define _BIRD_ROUTE_H_
! 11:
! 12: #include "lib/lists.h"
! 13: #include "lib/resource.h"
! 14: #include "lib/net.h"
! 15:
! 16: struct ea_list;
! 17: struct protocol;
! 18: struct proto;
! 19: struct rte_src;
! 20: struct symbol;
! 21: struct filter;
! 22: struct cli;
! 23:
! 24: /*
! 25: * Generic data structure for storing network prefixes. Also used
! 26: * for the master routing table. Currently implemented as a hash
! 27: * table.
! 28: *
! 29: * Available operations:
! 30: * - insertion of new entry
! 31: * - deletion of entry
! 32: * - searching for entry by network prefix
! 33: * - asynchronous retrieval of fib contents
! 34: */
! 35:
! 36: struct fib_node {
! 37: struct fib_node *next; /* Next in hash chain */
! 38: struct fib_iterator *readers; /* List of readers of this node */
! 39: byte flags; /* User-defined, will be removed */
! 40: net_addr addr[0];
! 41: };
! 42:
! 43: struct fib_iterator { /* See lib/slists.h for an explanation */
! 44: struct fib_iterator *prev, *next; /* Must be synced with struct fib_node! */
! 45: byte efef; /* 0xff to distinguish between iterator and node */
! 46: byte pad[3];
! 47: struct fib_node *node; /* Or NULL if freshly merged */
! 48: uint hash;
! 49: };
! 50:
! 51: typedef void (*fib_init_fn)(void *);
! 52:
! 53: struct fib {
! 54: pool *fib_pool; /* Pool holding all our data */
! 55: slab *fib_slab; /* Slab holding all fib nodes */
! 56: struct fib_node **hash_table; /* Node hash table */
! 57: uint hash_size; /* Number of hash table entries (a power of two) */
! 58: uint hash_order; /* Binary logarithm of hash_size */
! 59: uint hash_shift; /* 32 - hash_order */
! 60: uint addr_type; /* Type of address data stored in fib (NET_*) */
! 61: uint node_size; /* FIB node size, 0 for nonuniform */
! 62: uint node_offset; /* Offset of fib_node struct inside of user data */
! 63: uint entries; /* Number of entries */
! 64: uint entries_min, entries_max; /* Entry count limits (else start rehashing) */
! 65: fib_init_fn init; /* Constructor */
! 66: };
! 67:
! 68: static inline void * fib_node_to_user(struct fib *f, struct fib_node *e)
! 69: { return e ? (void *) ((char *) e - f->node_offset) : NULL; }
! 70:
! 71: static inline struct fib_node * fib_user_to_node(struct fib *f, void *e)
! 72: { return e ? (void *) ((char *) e + f->node_offset) : NULL; }
! 73:
! 74: void fib_init(struct fib *f, pool *p, uint addr_type, uint node_size, uint node_offset, uint hash_order, fib_init_fn init);
! 75: void *fib_find(struct fib *, const net_addr *); /* Find or return NULL if doesn't exist */
! 76: void *fib_get_chain(struct fib *f, const net_addr *a); /* Find first node in linked list from hash table */
! 77: void *fib_get(struct fib *, const net_addr *); /* Find or create new if nonexistent */
! 78: void *fib_route(struct fib *, const net_addr *); /* Longest-match routing lookup */
! 79: void fib_delete(struct fib *, void *); /* Remove fib entry */
! 80: void fib_free(struct fib *); /* Destroy the fib */
! 81: void fib_check(struct fib *); /* Consistency check for debugging */
! 82:
! 83: void fit_init(struct fib_iterator *, struct fib *); /* Internal functions, don't call */
! 84: struct fib_node *fit_get(struct fib *, struct fib_iterator *);
! 85: void fit_put(struct fib_iterator *, struct fib_node *);
! 86: void fit_put_next(struct fib *f, struct fib_iterator *i, struct fib_node *n, uint hpos);
! 87:
! 88:
! 89: #define FIB_WALK(fib, type, z) do { \
! 90: struct fib_node *fn_, **ff_ = (fib)->hash_table; \
! 91: uint count_ = (fib)->hash_size; \
! 92: type *z; \
! 93: while (count_--) \
! 94: for (fn_ = *ff_++; z = fib_node_to_user(fib, fn_); fn_=fn_->next)
! 95:
! 96: #define FIB_WALK_END } while (0)
! 97:
! 98: #define FIB_ITERATE_INIT(it, fib) fit_init(it, fib)
! 99:
! 100: #define FIB_ITERATE_START(fib, it, type, z) do { \
! 101: struct fib_node *fn_ = fit_get(fib, it); \
! 102: uint count_ = (fib)->hash_size; \
! 103: uint hpos_ = (it)->hash; \
! 104: type *z; \
! 105: for(;;) { \
! 106: if (!fn_) \
! 107: { \
! 108: if (++hpos_ >= count_) \
! 109: break; \
! 110: fn_ = (fib)->hash_table[hpos_]; \
! 111: continue; \
! 112: } \
! 113: z = fib_node_to_user(fib, fn_);
! 114:
! 115: #define FIB_ITERATE_END fn_ = fn_->next; } } while(0)
! 116:
! 117: #define FIB_ITERATE_PUT(it) fit_put(it, fn_)
! 118:
! 119: #define FIB_ITERATE_PUT_NEXT(it, fib) fit_put_next(fib, it, fn_, hpos_)
! 120:
! 121: #define FIB_ITERATE_UNLINK(it, fib) fit_get(fib, it)
! 122:
! 123:
! 124: /*
! 125: * Master Routing Tables. Generally speaking, each of them contains a FIB
! 126: * with each entry pointing to a list of route entries representing routes
! 127: * to given network (with the selected one at the head).
! 128: *
! 129: * Each of the RTE's contains variable data (the preference and protocol-dependent
! 130: * metrics) and a pointer to a route attribute block common for many routes).
! 131: *
! 132: * It's guaranteed that there is at most one RTE for every (prefix,proto) pair.
! 133: */
! 134:
! 135: struct rtable_config {
! 136: node n;
! 137: char *name;
! 138: struct rtable *table;
! 139: struct proto_config *krt_attached; /* Kernel syncer attached to this table */
! 140: uint addr_type; /* Type of address data stored in table (NET_*) */
! 141: int gc_max_ops; /* Maximum number of operations before GC is run */
! 142: int gc_min_time; /* Minimum time between two consecutive GC runs */
! 143: byte sorted; /* Routes of network are sorted according to rte_better() */
! 144: };
! 145:
! 146: typedef struct rtable {
! 147: node n; /* Node in list of all tables */
! 148: struct fib fib;
! 149: char *name; /* Name of this table */
! 150: list channels; /* List of attached channels (struct channel) */
! 151: uint addr_type; /* Type of address data stored in table (NET_*) */
! 152: int pipe_busy; /* Pipe loop detection */
! 153: int use_count; /* Number of protocols using this table */
! 154: u32 rt_count; /* Number of routes in the table */
! 155: struct hostcache *hostcache;
! 156: struct rtable_config *config; /* Configuration of this table */
! 157: struct config *deleted; /* Table doesn't exist in current configuration,
! 158: * delete as soon as use_count becomes 0 and remove
! 159: * obstacle from this routing table.
! 160: */
! 161: struct event *rt_event; /* Routing table event */
! 162: btime gc_time; /* Time of last GC */
! 163: int gc_counter; /* Number of operations since last GC */
! 164: byte prune_state; /* Table prune state, 1 -> scheduled, 2-> running */
! 165: byte hcu_scheduled; /* Hostcache update is scheduled */
! 166: byte nhu_state; /* Next Hop Update state */
! 167: struct fib_iterator prune_fit; /* Rtable prune FIB iterator */
! 168: struct fib_iterator nhu_fit; /* Next Hop Update FIB iterator */
! 169: } rtable;
! 170:
! 171: #define NHU_CLEAN 0
! 172: #define NHU_SCHEDULED 1
! 173: #define NHU_RUNNING 2
! 174: #define NHU_DIRTY 3
! 175:
! 176: typedef struct network {
! 177: struct rte *routes; /* Available routes for this network */
! 178: struct fib_node n; /* FIB flags reserved for kernel syncer */
! 179: } net;
! 180:
! 181: struct hostcache {
! 182: slab *slab; /* Slab holding all hostentries */
! 183: struct hostentry **hash_table; /* Hash table for hostentries */
! 184: unsigned hash_order, hash_shift;
! 185: unsigned hash_max, hash_min;
! 186: unsigned hash_items;
! 187: linpool *lp; /* Linpool for trie */
! 188: struct f_trie *trie; /* Trie of prefixes that might affect hostentries */
! 189: list hostentries; /* List of all hostentries */
! 190: byte update_hostcache;
! 191: };
! 192:
! 193: struct hostentry {
! 194: node ln;
! 195: ip_addr addr; /* IP address of host, part of key */
! 196: ip_addr link; /* (link-local) IP address of host, used as gw
! 197: if host is directly attached */
! 198: struct rtable *tab; /* Dependent table, part of key */
! 199: struct hostentry *next; /* Next in hash chain */
! 200: unsigned hash_key; /* Hash key */
! 201: unsigned uc; /* Use count */
! 202: struct rta *src; /* Source rta entry */
! 203: byte dest; /* Chosen route destination type (RTD_...) */
! 204: byte nexthop_linkable; /* Nexthop list is completely non-device */
! 205: u32 igp_metric; /* Chosen route IGP metric */
! 206: };
! 207:
! 208: typedef struct rte {
! 209: struct rte *next;
! 210: net *net; /* Network this RTE belongs to */
! 211: struct channel *sender; /* Channel used to send the route to the routing table */
! 212: struct rta *attrs; /* Attributes of this route */
! 213: byte flags; /* Flags (REF_...) */
! 214: byte pflags; /* Protocol-specific flags */
! 215: word pref; /* Route preference */
! 216: btime lastmod; /* Last modified */
! 217: union { /* Protocol-dependent data (metrics etc.) */
! 218: #ifdef CONFIG_RIP
! 219: struct {
! 220: struct iface *from; /* Incoming iface */
! 221: u8 metric; /* RIP metric */
! 222: u16 tag; /* External route tag */
! 223: } rip;
! 224: #endif
! 225: #ifdef CONFIG_OSPF
! 226: struct {
! 227: u32 metric1, metric2; /* OSPF Type 1 and Type 2 metrics */
! 228: u32 tag; /* External route tag */
! 229: u32 router_id; /* Router that originated this route */
! 230: } ospf;
! 231: #endif
! 232: #ifdef CONFIG_BGP
! 233: struct {
! 234: u8 suppressed; /* Used for deterministic MED comparison */
! 235: s8 stale; /* Route is LLGR_STALE, -1 if unknown */
! 236: } bgp;
! 237: #endif
! 238: #ifdef CONFIG_BABEL
! 239: struct {
! 240: u16 seqno; /* Babel seqno */
! 241: u16 metric; /* Babel metric */
! 242: u64 router_id; /* Babel router id */
! 243: } babel;
! 244: #endif
! 245: struct { /* Routes generated by krt sync (both temporary and inherited ones) */
! 246: s8 src; /* Alleged route source (see krt.h) */
! 247: u8 proto; /* Kernel source protocol ID */
! 248: u8 seen; /* Seen during last scan */
! 249: u8 best; /* Best route in network, propagated to core */
! 250: u32 metric; /* Kernel metric */
! 251: } krt;
! 252: } u;
! 253: } rte;
! 254:
! 255: #define REF_COW 1 /* Copy this rte on write */
! 256: #define REF_FILTERED 2 /* Route is rejected by import filter */
! 257: #define REF_STALE 4 /* Route is stale in a refresh cycle */
! 258: #define REF_DISCARD 8 /* Route is scheduled for discard */
! 259: #define REF_MODIFY 16 /* Route is scheduled for modify */
! 260:
! 261: /* Route is valid for propagation (may depend on other flags in the future), accepts NULL */
! 262: static inline int rte_is_valid(rte *r) { return r && !(r->flags & REF_FILTERED); }
! 263:
! 264: /* Route just has REF_FILTERED flag */
! 265: static inline int rte_is_filtered(rte *r) { return !!(r->flags & REF_FILTERED); }
! 266:
! 267:
! 268: /* Types of route announcement, also used as flags */
! 269: #define RA_UNDEF 0 /* Undefined RA type */
! 270: #define RA_OPTIMAL 1 /* Announcement of optimal route change */
! 271: #define RA_ACCEPTED 2 /* Announcement of first accepted route */
! 272: #define RA_ANY 3 /* Announcement of any route change */
! 273: #define RA_MERGED 4 /* Announcement of optimal route merged with next ones */
! 274:
! 275: /* Return value of preexport() callback */
! 276: #define RIC_ACCEPT 1 /* Accepted by protocol */
! 277: #define RIC_PROCESS 0 /* Process it through import filter */
! 278: #define RIC_REJECT -1 /* Rejected by protocol */
! 279: #define RIC_DROP -2 /* Silently dropped by protocol */
! 280:
! 281: extern list routing_tables;
! 282: struct config;
! 283:
! 284: void rt_init(void);
! 285: void rt_preconfig(struct config *);
! 286: void rt_commit(struct config *new, struct config *old);
! 287: void rt_lock_table(rtable *);
! 288: void rt_unlock_table(rtable *);
! 289: void rt_setup(pool *, rtable *, struct rtable_config *);
! 290: static inline net *net_find(rtable *tab, const net_addr *addr) { return (net *) fib_find(&tab->fib, addr); }
! 291: static inline net *net_find_valid(rtable *tab, const net_addr *addr)
! 292: { net *n = net_find(tab, addr); return (n && rte_is_valid(n->routes)) ? n : NULL; }
! 293: static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) fib_get(&tab->fib, addr); }
! 294: void *net_route(rtable *tab, const net_addr *n);
! 295: int net_roa_check(rtable *tab, const net_addr *n, u32 asn);
! 296: rte *rte_find(net *net, struct rte_src *src);
! 297: rte *rte_get_temp(struct rta *);
! 298: void rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
! 299: /* rte_update() moved to protocol.h to avoid dependency conflicts */
! 300: int rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter);
! 301: rte *rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int silent);
! 302: void rt_refresh_begin(rtable *t, struct channel *c);
! 303: void rt_refresh_end(rtable *t, struct channel *c);
! 304: void rt_modify_stale(rtable *t, struct channel *c);
! 305: void rt_schedule_prune(rtable *t);
! 306: void rte_dump(rte *);
! 307: void rte_free(rte *);
! 308: rte *rte_do_cow(rte *);
! 309: static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
! 310: rte *rte_cow_rta(rte *r, linpool *lp);
! 311: void rte_init_tmp_attrs(struct rte *r, linpool *lp, uint max);
! 312: void rte_make_tmp_attr(struct rte *r, uint id, uint type, uintptr_t val);
! 313: void rte_make_tmp_attrs(struct rte **r, struct linpool *pool, struct rta **old_attrs);
! 314: uintptr_t rte_store_tmp_attr(struct rte *r, uint id);
! 315: void rt_dump(rtable *);
! 316: void rt_dump_all(void);
! 317: int rt_feed_channel(struct channel *c);
! 318: void rt_feed_channel_abort(struct channel *c);
! 319: int rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
! 320: int rt_reload_channel(struct channel *c);
! 321: void rt_reload_channel_abort(struct channel *c);
! 322: void rt_prune_sync(rtable *t, int all);
! 323: int rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old0, int refeed);
! 324: struct rtable_config *rt_new_table(struct symbol *s, uint addr_type);
! 325:
! 326:
! 327: /* Default limit for ECMP next hops, defined in sysdep code */
! 328: extern const int rt_default_ecmp;
! 329:
! 330: struct rt_show_data_rtable {
! 331: node n;
! 332: rtable *table;
! 333: struct channel *export_channel;
! 334: };
! 335:
! 336: struct rt_show_data {
! 337: net_addr *addr;
! 338: list tables;
! 339: struct rt_show_data_rtable *tab; /* Iterator over table list */
! 340: struct rt_show_data_rtable *last_table; /* Last table in output */
! 341: struct fib_iterator fit; /* Iterator over networks in table */
! 342: int verbose, tables_defined_by;
! 343: const struct filter *filter;
! 344: struct proto *show_protocol;
! 345: struct proto *export_protocol;
! 346: struct channel *export_channel;
! 347: struct config *running_on_config;
! 348: int export_mode, primary_only, filtered, stats, show_for;
! 349:
! 350: int table_open; /* Iteration (fit) is open */
! 351: int net_counter, rt_counter, show_counter, table_counter;
! 352: int net_counter_last, rt_counter_last, show_counter_last;
! 353: };
! 354:
! 355: void rt_show(struct rt_show_data *);
! 356: struct rt_show_data_rtable * rt_show_add_table(struct rt_show_data *d, rtable *t);
! 357:
! 358: /* Value of table definition mode in struct rt_show_data */
! 359: #define RSD_TDB_DEFAULT 0 /* no table specified */
! 360: #define RSD_TDB_INDIRECT 0 /* show route ... protocol P ... */
! 361: #define RSD_TDB_ALL RSD_TDB_SET /* show route ... table all ... */
! 362: #define RSD_TDB_DIRECT RSD_TDB_SET | RSD_TDB_NMN /* show route ... table X table Y ... */
! 363:
! 364: #define RSD_TDB_SET 0x1 /* internal: show empty tables */
! 365: #define RSD_TDB_NMN 0x2 /* internal: need matching net */
! 366:
! 367: /* Value of export_mode in struct rt_show_data */
! 368: #define RSEM_NONE 0 /* Export mode not used */
! 369: #define RSEM_PREEXPORT 1 /* Routes ready for export, before filtering */
! 370: #define RSEM_EXPORT 2 /* Routes accepted by export filter */
! 371: #define RSEM_NOEXPORT 3 /* Routes rejected by export filter */
! 372:
! 373: /*
! 374: * Route Attributes
! 375: *
! 376: * Beware: All standard BGP attributes must be represented here instead
! 377: * of making them local to the route. This is needed to ensure proper
! 378: * construction of BGP route attribute lists.
! 379: */
! 380:
! 381: /* Nexthop structure */
! 382: struct nexthop {
! 383: ip_addr gw; /* Next hop */
! 384: struct iface *iface; /* Outgoing interface */
! 385: struct nexthop *next;
! 386: byte flags;
! 387: byte weight;
! 388: byte labels_orig; /* Number of labels before hostentry was applied */
! 389: byte labels; /* Number of all labels */
! 390: u32 label[0];
! 391: };
! 392:
! 393: #define RNF_ONLINK 0x1 /* Gateway is onlink regardless of IP ranges */
! 394:
! 395:
! 396: struct rte_src {
! 397: struct rte_src *next; /* Hash chain */
! 398: struct proto *proto; /* Protocol the source is based on */
! 399: u32 private_id; /* Private ID, assigned by the protocol */
! 400: u32 global_id; /* Globally unique ID of the source */
! 401: unsigned uc; /* Use count */
! 402: };
! 403:
! 404:
! 405: typedef struct rta {
! 406: struct rta *next, **pprev; /* Hash chain */
! 407: u32 uc; /* Use count */
! 408: u32 hash_key; /* Hash over important fields */
! 409: struct ea_list *eattrs; /* Extended Attribute chain */
! 410: struct rte_src *src; /* Route source that created the route */
! 411: struct hostentry *hostentry; /* Hostentry for recursive next-hops */
! 412: ip_addr from; /* Advertising router */
! 413: u32 igp_metric; /* IGP metric to next hop (for iBGP routes) */
! 414: u8 source; /* Route source (RTS_...) */
! 415: u8 scope; /* Route scope (SCOPE_... -- see ip.h) */
! 416: u8 dest; /* Route destination type (RTD_...) */
! 417: u8 aflags;
! 418: struct nexthop nh; /* Next hop */
! 419: } rta;
! 420:
! 421: #define RTS_DUMMY 0 /* Dummy route to be removed soon */
! 422: #define RTS_STATIC 1 /* Normal static route */
! 423: #define RTS_INHERIT 2 /* Route inherited from kernel */
! 424: #define RTS_DEVICE 3 /* Device route */
! 425: #define RTS_STATIC_DEVICE 4 /* Static device route */
! 426: #define RTS_REDIRECT 5 /* Learned via redirect */
! 427: #define RTS_RIP 6 /* RIP route */
! 428: #define RTS_OSPF 7 /* OSPF route */
! 429: #define RTS_OSPF_IA 8 /* OSPF inter-area route */
! 430: #define RTS_OSPF_EXT1 9 /* OSPF external route type 1 */
! 431: #define RTS_OSPF_EXT2 10 /* OSPF external route type 2 */
! 432: #define RTS_BGP 11 /* BGP route */
! 433: #define RTS_PIPE 12 /* Inter-table wormhole */
! 434: #define RTS_BABEL 13 /* Babel route */
! 435: #define RTS_RPKI 14 /* Route Origin Authorization */
! 436: #define RTS_PERF 15 /* Perf checker */
! 437: #define RTS_MAX 16
! 438:
! 439: #define RTC_UNICAST 0
! 440: #define RTC_BROADCAST 1
! 441: #define RTC_MULTICAST 2
! 442: #define RTC_ANYCAST 3 /* IPv6 Anycast */
! 443:
! 444: #define RTD_NONE 0 /* Undefined next hop */
! 445: #define RTD_UNICAST 1 /* Next hop is neighbor router */
! 446: #define RTD_BLACKHOLE 2 /* Silently drop packets */
! 447: #define RTD_UNREACHABLE 3 /* Reject as unreachable */
! 448: #define RTD_PROHIBIT 4 /* Administratively prohibited */
! 449: #define RTD_MAX 5
! 450:
! 451: /* Flags for net->n.flags, used by kernel syncer */
! 452: #define KRF_INSTALLED 0x80 /* This route should be installed in the kernel */
! 453: #define KRF_SYNC_ERROR 0x40 /* Error during kernel table synchronization */
! 454:
! 455: #define RTAF_CACHED 1 /* This is a cached rta */
! 456:
! 457: #define IGP_METRIC_UNKNOWN 0x80000000 /* Default igp_metric used when no other
! 458: protocol-specific metric is availabe */
! 459:
! 460:
! 461: const char * rta_dest_names[RTD_MAX];
! 462:
! 463: static inline const char *rta_dest_name(uint n)
! 464: { return (n < RTD_MAX) ? rta_dest_names[n] : "???"; }
! 465:
! 466: /* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
! 467: static inline int rte_is_reachable(rte *r)
! 468: { return r->attrs->dest == RTD_UNICAST; }
! 469:
! 470:
! 471: /*
! 472: * Extended Route Attributes
! 473: */
! 474:
! 475: typedef struct eattr {
! 476: word id; /* EA_CODE(PROTOCOL_..., protocol-dependent ID) */
! 477: byte flags; /* Protocol-dependent flags */
! 478: byte type; /* Attribute type and several flags (EAF_...) */
! 479: union {
! 480: u32 data;
! 481: const struct adata *ptr; /* Attribute data elsewhere */
! 482: } u;
! 483: } eattr;
! 484:
! 485:
! 486: #define EA_CODE(proto,id) (((proto) << 8) | (id))
! 487: #define EA_ID(ea) ((ea) & 0xff)
! 488: #define EA_PROTO(ea) ((ea) >> 8)
! 489: #define EA_ID_FLAG(ea) (1 << EA_ID(ea))
! 490: #define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT)
! 491: #define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
! 492: #define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
! 493:
! 494: const char *ea_custom_name(uint ea);
! 495:
! 496: #define EA_GEN_IGP_METRIC EA_CODE(PROTOCOL_NONE, 0)
! 497:
! 498: #define EA_CODE_MASK 0xffff
! 499: #define EA_CUSTOM_BIT 0x8000
! 500: #define EA_ALLOW_UNDEF 0x10000 /* ea_find: allow EAF_TYPE_UNDEF */
! 501: #define EA_BIT(n) ((n) << 24) /* Used in bitfield accessors */
! 502: #define EA_BIT_GET(ea) ((ea) >> 24)
! 503:
! 504: #define EAF_TYPE_MASK 0x1f /* Mask with this to get type */
! 505: #define EAF_TYPE_INT 0x01 /* 32-bit unsigned integer number */
! 506: #define EAF_TYPE_OPAQUE 0x02 /* Opaque byte string (not filterable) */
! 507: #define EAF_TYPE_IP_ADDRESS 0x04 /* IP address */
! 508: #define EAF_TYPE_ROUTER_ID 0x05 /* Router ID (IPv4 address) */
! 509: #define EAF_TYPE_AS_PATH 0x06 /* BGP AS path (encoding per RFC 1771:4.3) */
! 510: #define EAF_TYPE_BITFIELD 0x09 /* 32-bit embedded bitfield */
! 511: #define EAF_TYPE_INT_SET 0x0a /* Set of u32's (e.g., a community list) */
! 512: #define EAF_TYPE_EC_SET 0x0e /* Set of pairs of u32's - ext. community list */
! 513: #define EAF_TYPE_LC_SET 0x12 /* Set of triplets of u32's - large community list */
! 514: #define EAF_TYPE_UNDEF 0x1f /* `force undefined' entry */
! 515: #define EAF_EMBEDDED 0x01 /* Data stored in eattr.u.data (part of type spec) */
! 516: #define EAF_VAR_LENGTH 0x02 /* Attribute length is variable (part of type spec) */
! 517: #define EAF_ORIGINATED 0x20 /* The attribute has originated locally */
! 518: #define EAF_FRESH 0x40 /* An uncached attribute (e.g. modified in export filter) */
! 519:
! 520: typedef struct adata {
! 521: uint length; /* Length of data */
! 522: byte data[0];
! 523: } adata;
! 524:
! 525: extern const adata null_adata; /* adata of length 0 */
! 526:
! 527: static inline struct adata *
! 528: lp_alloc_adata(struct linpool *pool, uint len)
! 529: {
! 530: struct adata *ad = lp_alloc(pool, sizeof(struct adata) + len);
! 531: ad->length = len;
! 532: return ad;
! 533: }
! 534:
! 535: static inline int adata_same(const struct adata *a, const struct adata *b)
! 536: { return (a->length == b->length && !memcmp(a->data, b->data, a->length)); }
! 537:
! 538:
! 539: typedef struct ea_list {
! 540: struct ea_list *next; /* In case we have an override list */
! 541: byte flags; /* Flags: EALF_... */
! 542: byte rfu;
! 543: word count; /* Number of attributes */
! 544: eattr attrs[0]; /* Attribute definitions themselves */
! 545: } ea_list;
! 546:
! 547: #define EALF_SORTED 1 /* Attributes are sorted by code */
! 548: #define EALF_BISECT 2 /* Use interval bisection for searching */
! 549: #define EALF_CACHED 4 /* Attributes belonging to cached rta */
! 550: #define EALF_TEMP 8 /* Temporary ea_list added by make_tmp_attrs hooks */
! 551:
! 552: struct rte_src *rt_find_source(struct proto *p, u32 id);
! 553: struct rte_src *rt_get_source(struct proto *p, u32 id);
! 554: static inline void rt_lock_source(struct rte_src *src) { src->uc++; }
! 555: static inline void rt_unlock_source(struct rte_src *src) { src->uc--; }
! 556: void rt_prune_sources(void);
! 557:
! 558: struct ea_walk_state {
! 559: ea_list *eattrs; /* Ccurrent ea_list, initially set by caller */
! 560: eattr *ea; /* Current eattr, initially NULL */
! 561: u32 visited[4]; /* Bitfield, limiting max to 128 */
! 562: };
! 563:
! 564: eattr *ea_find(ea_list *, unsigned ea);
! 565: eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
! 566: int ea_get_int(ea_list *, unsigned ea, int def);
! 567: void ea_dump(ea_list *);
! 568: void ea_sort(ea_list *); /* Sort entries in all sub-lists */
! 569: unsigned ea_scan(ea_list *); /* How many bytes do we need for merged ea_list */
! 570: void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffer */
! 571: int ea_same(ea_list *x, ea_list *y); /* Test whether two ea_lists are identical */
! 572: uint ea_hash(ea_list *e); /* Calculate 16-bit hash value */
! 573: ea_list *ea_append(ea_list *to, ea_list *what);
! 574: void ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max);
! 575:
! 576: #define ea_normalize(ea) do { \
! 577: if (ea->next) { \
! 578: ea_list *t = alloca(ea_scan(ea)); \
! 579: ea_merge(ea, t); \
! 580: ea = t; \
! 581: } \
! 582: ea_sort(ea); \
! 583: if (ea->count == 0) \
! 584: ea = NULL; \
! 585: } while(0) \
! 586:
! 587: static inline eattr *
! 588: ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, uintptr_t val)
! 589: {
! 590: ea_list *a = lp_alloc(pool, sizeof(ea_list) + sizeof(eattr));
! 591: eattr *e = &a->attrs[0];
! 592:
! 593: a->flags = EALF_SORTED;
! 594: a->count = 1;
! 595: a->next = *to;
! 596: *to = a;
! 597:
! 598: e->id = id;
! 599: e->type = type;
! 600: e->flags = flags;
! 601:
! 602: if (type & EAF_EMBEDDED)
! 603: e->u.data = (u32) val;
! 604: else
! 605: e->u.ptr = (struct adata *) val;
! 606:
! 607: return e;
! 608: }
! 609:
! 610: static inline void
! 611: ea_set_attr_u32(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, u32 val)
! 612: { ea_set_attr(to, pool, id, flags, type, (uintptr_t) val); }
! 613:
! 614: static inline void
! 615: ea_set_attr_ptr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, struct adata *val)
! 616: { ea_set_attr(to, pool, id, flags, type, (uintptr_t) val); }
! 617:
! 618: static inline void
! 619: ea_set_attr_data(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, void *data, uint len)
! 620: {
! 621: struct adata *a = lp_alloc_adata(pool, len);
! 622: memcpy(a->data, data, len);
! 623: ea_set_attr(to, pool, id, flags, type, (uintptr_t) a);
! 624: }
! 625:
! 626:
! 627: #define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
! 628:
! 629: static inline size_t nexthop_size(const struct nexthop *nh)
! 630: { return sizeof(struct nexthop) + sizeof(u32)*nh->labels; }
! 631: int nexthop__same(struct nexthop *x, struct nexthop *y); /* Compare multipath nexthops */
! 632: static inline int nexthop_same(struct nexthop *x, struct nexthop *y)
! 633: { return (x == y) || nexthop__same(x, y); }
! 634: struct nexthop *nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp);
! 635: struct nexthop *nexthop_sort(struct nexthop *x);
! 636: static inline void nexthop_link(struct rta *a, struct nexthop *from)
! 637: { memcpy(&a->nh, from, nexthop_size(from)); }
! 638: void nexthop_insert(struct nexthop **n, struct nexthop *y);
! 639: int nexthop_is_sorted(struct nexthop *x);
! 640:
! 641: void rta_init(void);
! 642: static inline size_t rta_size(const rta *a) { return sizeof(rta) + sizeof(u32)*a->nh.labels; }
! 643: #define RTA_MAX_SIZE (sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
! 644: rta *rta_lookup(rta *); /* Get rta equivalent to this one, uc++ */
! 645: static inline int rta_is_cached(rta *r) { return r->aflags & RTAF_CACHED; }
! 646: static inline rta *rta_clone(rta *r) { r->uc++; return r; }
! 647: void rta__free(rta *r);
! 648: static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
! 649: rta *rta_do_cow(rta *o, linpool *lp);
! 650: static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
! 651: void rta_dump(rta *);
! 652: void rta_dump_all(void);
! 653: void rta_show(struct cli *, rta *);
! 654:
! 655: u32 rt_get_igp_metric(rte *rt);
! 656: struct hostentry * rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
! 657: void rta_apply_hostentry(rta *a, struct hostentry *he, mpls_label_stack *mls);
! 658:
! 659: static inline void
! 660: rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr gw, ip_addr ll, mpls_label_stack *mls)
! 661: {
! 662: rta_apply_hostentry(a, rt_get_hostentry(tab, gw, ll, dep), mls);
! 663: }
! 664:
! 665: /*
! 666: * rta_set_recursive_next_hop() acquires hostentry from hostcache and fills
! 667: * rta->hostentry field. New hostentry has zero use count. Cached rta locks its
! 668: * hostentry (increases its use count), uncached rta does not lock it. Hostentry
! 669: * with zero use count is removed asynchronously during host cache update,
! 670: * therefore it is safe to hold such hostentry temorarily. Hostentry holds a
! 671: * lock for a 'source' rta, mainly to share multipath nexthops.
! 672: *
! 673: * There is no need to hold a lock for hostentry->dep table, because that table
! 674: * contains routes responsible for that hostentry, and therefore is non-empty if
! 675: * given hostentry has non-zero use count. If the hostentry has zero use count,
! 676: * the entry is removed before dep is referenced.
! 677: *
! 678: * The protocol responsible for routes with recursive next hops should hold a
! 679: * lock for a 'source' table governing that routes (argument tab to
! 680: * rta_set_recursive_next_hop()), because its routes reference hostentries
! 681: * (through rta) related to the governing table. When all such routes are
! 682: * removed, rtas are immediately removed achieving zero uc. Then the 'source'
! 683: * table lock could be immediately released, although hostentries may still
! 684: * exist - they will be freed together with the 'source' table.
! 685: */
! 686:
! 687: static inline void rt_lock_hostentry(struct hostentry *he) { if (he) he->uc++; }
! 688: static inline void rt_unlock_hostentry(struct hostentry *he) { if (he) he->uc--; }
! 689:
! 690: /*
! 691: * Default protocol preferences
! 692: */
! 693:
! 694: #define DEF_PREF_DIRECT 240 /* Directly connected */
! 695: #define DEF_PREF_STATIC 200 /* Static route */
! 696: #define DEF_PREF_OSPF 150 /* OSPF intra-area, inter-area and type 1 external routes */
! 697: #define DEF_PREF_BABEL 130 /* Babel */
! 698: #define DEF_PREF_RIP 120 /* RIP */
! 699: #define DEF_PREF_BGP 100 /* BGP */
! 700: #define DEF_PREF_RPKI 100 /* RPKI */
! 701: #define DEF_PREF_INHERITED 10 /* Routes inherited from other routing daemons */
! 702:
! 703: /*
! 704: * Route Origin Authorization
! 705: */
! 706:
! 707: #define ROA_UNKNOWN 0
! 708: #define ROA_VALID 1
! 709: #define ROA_INVALID 2
! 710:
! 711: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to route.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / nest