nest/protocol.h

   1 /*
   2  *      BIRD Internet Routing Daemon -- Protocols
   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_PROTOCOL_H_
  10 #define _BIRD_PROTOCOL_H_
  11
  12 #include "lib/lists.h"
  13 #include "lib/resource.h"
  14 #include "lib/timer.h"
  15 #include "nest/route.h"
  16 #include "conf/conf.h"
  17
  18 struct iface;
  19 struct ifa;
  20 struct rtable;
  21 struct rte;
  22 struct neighbor;
  23 struct rta;
  24 struct network;
  25 struct proto_config;
  26 struct config;
  27 struct proto;
  28 struct event;
  29 struct ea_list;
  30 struct eattr;
  31 struct symbol;
  32
  33 /*
  34  *      Routing Protocol
  35  */
  36
  37 struct protocol {
  38   node n;
  39   char *name;
  40   char *template;                       /* Template for automatic generation of names */
  41   int name_counter;                     /* Counter for automatic name generation */
  42   int attr_class;                       /* Attribute class known to this protocol */
  43   int multitable;                       /* Protocol handles all announce hooks itself */
  44   uint preference;                      /* Default protocol preference */
  45   uint config_size;                     /* Size of protocol config */
  46
  47   void (*preconfig)(struct protocol *, struct config *);        /* Just before configuring */
  48   void (*postconfig)(struct proto_config *);                    /* After configuring each instance */
  49   struct proto * (*init)(struct proto_config *);                /* Create new instance */
  50   int (*reconfigure)(struct proto *, struct proto_config *);    /* Try to reconfigure instance, returns success */
  51   void (*dump)(struct proto *);                 /* Debugging dump */
  52   void (*dump_attrs)(struct rte *);             /* Dump protocol-dependent attributes */
  53   int (*start)(struct proto *);                 /* Start the instance */
  54   int (*shutdown)(struct proto *);              /* Stop the instance */
  55   void (*cleanup)(struct proto *);              /* Called after shutdown when protocol became hungry/down */
  56   void (*get_status)(struct proto *, byte *buf); /* Get instance status (for `show protocols' command) */
  57   void (*get_route_info)(struct rte *, byte *buf, struct ea_list *attrs); /* Get route information (for `show route' command) */
  58   int (*get_attr)(struct eattr *, byte *buf, int buflen);       /* ASCIIfy dynamic attribute (returns GA_*) */
  59   void (*show_proto_info)(struct proto *);      /* Show protocol info (for `show protocols all' command) */
  60   void (*copy_config)(struct proto_config *, struct proto_config *);    /* Copy config from given protocol instance */
  61 };
  62
  63 void protos_build(void);
  64 void proto_build(struct protocol *);
  65 void protos_preconfig(struct config *);
  66 void protos_postconfig(struct config *);
  67 void protos_commit(struct config *new, struct config *old, int force_restart, int type);
  68 void protos_dump_all(void);
  69
  70 #define GA_UNKNOWN      0               /* Attribute not recognized */
  71 #define GA_NAME         1               /* Result = name */
  72 #define GA_FULL         2               /* Result = both name and value */
  73
  74 /*
  75  *      Known protocols
  76  */
  77
  78 extern struct protocol
  79   proto_device, proto_radv, proto_rip, proto_static,
  80   proto_ospf, proto_pipe, proto_bgp, proto_bfd, proto_babel;
  81
  82 /*
  83  *      Routing Protocol Instance
  84  */
  85
  86 struct proto_config {
  87   node n;
  88   struct config *global;                /* Global configuration data */
  89   struct protocol *protocol;            /* Protocol */
  90   struct proto *proto;                  /* Instance we've created */
  91   char *name;
  92   char *dsc;
  93   int class;                            /* SYM_PROTO or SYM_TEMPLATE */
  94   u32 debug, mrtdump;                   /* Debugging bitfields, both use D_* constants */
  95   unsigned preference, disabled;        /* Generic parameters */
  96   int in_keep_filtered;                 /* Routes rejected in import filter are kept */
  97   u32 router_id;                        /* Protocol specific router ID */
  98   struct iface *vrf;                    /* Related VRF instance, NULL if global */
  99   struct rtable_config *table;          /* Table we're attached to */
 100   struct filter *in_filter, *out_filter; /* Attached filters */
 101   struct proto_limit *rx_limit;         /* Limit for receiving routes from protocol
 102                                            (relevant when in_keep_filtered is active) */
 103   struct proto_limit *in_limit;         /* Limit for importing routes from protocol */
 104   struct proto_limit *out_limit;        /* Limit for exporting routes to protocol */
 105
 106   /* Check proto_reconfigure() and proto_copy_config() after changing struct proto_config */
 107
 108   /* Protocol-specific data follow... */
 109 };
 110
 111 /* Protocol statistics */
 112 struct proto_stats {
 113   /* Import - from protocol to core */
 114   u32 imp_routes;               /* Number of routes successfully imported to the (adjacent) routing table */
 115   u32 filt_routes;              /* Number of routes rejected in import filter but kept in the routing table */
 116   u32 pref_routes;              /* Number of routes that are preferred, sum over all routing tables */
 117   u32 imp_updates_received;     /* Number of route updates received */
 118   u32 imp_updates_invalid;      /* Number of route updates rejected as invalid */
 119   u32 imp_updates_filtered;     /* Number of route updates rejected by filters */
 120   u32 imp_updates_ignored;      /* Number of route updates rejected as already in route table */
 121   u32 imp_updates_accepted;     /* Number of route updates accepted and imported */
 122   u32 imp_withdraws_received;   /* Number of route withdraws received */
 123   u32 imp_withdraws_invalid;    /* Number of route withdraws rejected as invalid */
 124   u32 imp_withdraws_ignored;    /* Number of route withdraws rejected as already not in route table */
 125   u32 imp_withdraws_accepted;   /* Number of route withdraws accepted and processed */
 126
 127   /* Export - from core to protocol */
 128   u32 exp_routes;               /* Number of routes successfully exported to the protocol */
 129   u32 exp_updates_received;     /* Number of route updates received */
 130   u32 exp_updates_rejected;     /* Number of route updates rejected by protocol */
 131   u32 exp_updates_filtered;     /* Number of route updates rejected by filters */
 132   u32 exp_updates_accepted;     /* Number of route updates accepted and exported */
 133   u32 exp_withdraws_received;   /* Number of route withdraws received */
 134   u32 exp_withdraws_accepted;   /* Number of route withdraws accepted and processed */
 135 };
 136
 137 struct proto {
 138   node n;                               /* Node in *_proto_list */
 139   node glob_node;                       /* Node in global proto_list */
 140   struct protocol *proto;               /* Protocol */
 141   struct proto_config *cf;              /* Configuration data */
 142   struct proto_config *cf_new;          /* Configuration we want to switch to after shutdown (NULL=delete) */
 143   pool *pool;                           /* Pool containing local objects */
 144   struct event *attn;                   /* "Pay attention" event */
 145
 146   char *name;                           /* Name of this instance (== cf->name) */
 147   u32 debug;                            /* Debugging flags */
 148   u32 mrtdump;                          /* MRTDump flags */
 149   unsigned preference;                  /* Default route preference */
 150   byte accept_ra_types;                 /* Which types of route announcements are accepted (RA_OPTIMAL or RA_ANY) */
 151   byte disabled;                        /* Manually disabled */
 152   byte proto_state;                     /* Protocol state machine (PS_*, see below) */
 153   byte core_state;                      /* Core state machine (FS_*, see below) */
 154   byte export_state;                    /* Route export state (ES_*, see below) */
 155   byte reconfiguring;                   /* We're shutting down due to reconfiguration */
 156   byte refeeding;                       /* We are refeeding (valid only if export_state == ES_FEEDING) */
 157   byte flushing;                        /* Protocol is flushed in current flush loop round */
 158   byte gr_recovery;                     /* Protocol should participate in graceful restart recovery */
 159   byte gr_lock;                         /* Graceful restart mechanism should wait for this proto */
 160   byte gr_wait;                         /* Route export to protocol is postponed until graceful restart */
 161   byte down_sched;                      /* Shutdown is scheduled for later (PDS_*) */
 162   byte down_code;                       /* Reason for shutdown (PDC_* codes) */
 163   byte merge_limit;                     /* Maximal number of nexthops for RA_MERGED */
 164   u32 hash_key;                         /* Random key used for hashing of neighbors */
 165   bird_clock_t last_state_change;       /* Time of last state transition */
 166   char *last_state_name_announced;      /* Last state name we've announced to the user */
 167   struct proto_stats stats;             /* Current protocol statistics */
 168
 169   /*
 170    *    General protocol hooks:
 171    *
 172    *       if_notify    Notify protocol about interface state changes.
 173    *       ifa_notify   Notify protocol about interface address changes.
 174    *       rt_notify    Notify protocol about routing table updates.
 175    *       neigh_notify Notify protocol about neighbor cache events.
 176    *       make_tmp_attrs  Construct ea_list from private attrs stored in rte.
 177    *       store_tmp_attrs Store private attrs back to the rte.
 178    *       import_control  Called as the first step of the route importing process.
 179    *                    It can construct a new rte, add private attributes and
 180    *                    decide whether the route shall be imported: 1=yes, -1=no,
 181    *                    0=process it through the import filter set by the user.
 182    *       reload_routes   Request protocol to reload all its routes to the core
 183    *                    (using rte_update()). Returns: 0=reload cannot be done,
 184    *                    1= reload is scheduled and will happen (asynchronously).
 185    *       feed_begin   Notify protocol about beginning of route feeding.
 186    *       feed_end     Notify protocol about finish of route feeding.
 187    */
 188
 189   void (*if_notify)(struct proto *, unsigned flags, struct iface *i);
 190   void (*ifa_notify)(struct proto *, unsigned flags, struct ifa *a);
 191   void (*rt_notify)(struct proto *, struct rtable *table, struct network *net, struct rte *new, struct rte *old, struct ea_list *attrs);
 192   void (*neigh_notify)(struct neighbor *neigh);
 193   struct ea_list *(*make_tmp_attrs)(struct rte *rt, struct linpool *pool);
 194   void (*store_tmp_attrs)(struct rte *rt, struct ea_list *attrs);
 195   int (*import_control)(struct proto *, struct rte **rt, struct ea_list **attrs, struct linpool *pool);
 196   int (*reload_routes)(struct proto *);
 197   void (*feed_begin)(struct proto *, int initial);
 198   void (*feed_end)(struct proto *);
 199
 200   /*
 201    *    Routing entry hooks (called only for routes belonging to this protocol):
 202    *
 203    *       rte_recalculate Called at the beginning of the best route selection
 204    *       rte_better   Compare two rte's and decide which one is better (1=first, 0=second).
 205    *       rte_same     Compare two rte's and decide whether they are identical (1=yes, 0=no).
 206    *       rte_mergable Compare two rte's and decide whether they could be merged (1=yes, 0=no).
 207    *       rte_insert   Called whenever a rte is inserted to a routing table.
 208    *       rte_remove   Called whenever a rte is removed from the routing table.
 209    */
 210
 211   int (*rte_recalculate)(struct rtable *, struct network *, struct rte *, struct rte *, struct rte *);
 212   int (*rte_better)(struct rte *, struct rte *);
 213   int (*rte_same)(struct rte *, struct rte *);
 214   int (*rte_mergable)(struct rte *, struct rte *);
 215   void (*rte_insert)(struct network *, struct rte *);
 216   void (*rte_remove)(struct network *, struct rte *);
 217
 218   struct iface *vrf;                    /* Related VRF instance, NULL if global */
 219   struct rtable *table;                 /* Our primary routing table */
 220   struct rte_src *main_source;          /* Primary route source */
 221   struct announce_hook *main_ahook;     /* Primary announcement hook */
 222   struct announce_hook *ahooks;         /* Announcement hooks for this protocol */
 223
 224   struct fib_iterator *feed_iterator;   /* Routing table iterator used during protocol feeding */
 225   struct announce_hook *feed_ahook;     /* Announce hook we currently feed */
 226
 227   /* Hic sunt protocol-specific data */
 228 };
 229
 230 struct proto_spec {
 231   void *ptr;
 232   int patt;
 233 };
 234
 235
 236 #define PDS_DISABLE             1       /* Proto disable scheduled */
 237 #define PDS_RESTART             2       /* Proto restart scheduled */
 238
 239 #define PDC_CF_REMOVE           0x01    /* Removed in new config */
 240 #define PDC_CF_DISABLE          0x02    /* Disabled in new config */
 241 #define PDC_CF_RESTART          0x03    /* Restart due to reconfiguration */
 242 #define PDC_CMD_DISABLE         0x11    /* Result of disable command */
 243 #define PDC_CMD_RESTART         0x12    /* Result of restart command */
 244 #define PDC_CMD_SHUTDOWN        0x13    /* Result of global shutdown */
 245 #define PDC_RX_LIMIT_HIT        0x21    /* Route receive limit reached */
 246 #define PDC_IN_LIMIT_HIT        0x22    /* Route import limit reached */
 247 #define PDC_OUT_LIMIT_HIT       0x23    /* Route export limit reached */
 248
 249
 250 void *proto_new(struct proto_config *, unsigned size);
 251 void *proto_config_new(struct protocol *, int class);
 252 void proto_copy_config(struct proto_config *dest, struct proto_config *src);
 253 void proto_request_feeding(struct proto *p);
 254
 255 static inline void
 256 proto_copy_rest(struct proto_config *dest, struct proto_config *src, unsigned size)
 257 { memcpy(dest + 1, src + 1, size - sizeof(struct proto_config)); }
 258
 259 void graceful_restart_recovery(void);
 260 void graceful_restart_init(void);
 261 void graceful_restart_show_status(void);
 262 void proto_graceful_restart_lock(struct proto *p);
 263 void proto_graceful_restart_unlock(struct proto *p);
 264
 265 #define DEFAULT_GR_WAIT 240
 266
 267 void proto_show_limit(struct proto_limit *l, const char *dsc);
 268 void proto_show_basic_info(struct proto *p);
 269
 270 void proto_cmd_show(struct proto *, uint, int);
 271 void proto_cmd_disable(struct proto *, uint, int);
 272 void proto_cmd_enable(struct proto *, uint, int);
 273 void proto_cmd_restart(struct proto *, uint, int);
 274 void proto_cmd_reload(struct proto *, uint, int);
 275 void proto_cmd_debug(struct proto *, uint, int);
 276 void proto_cmd_mrtdump(struct proto *, uint, int);
 277
 278 void proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, uint, int), int restricted, uint arg);
 279 struct proto *proto_get_named(struct symbol *, struct protocol *);
 280
 281 #define CMD_RELOAD      0
 282 #define CMD_RELOAD_IN   1
 283 #define CMD_RELOAD_OUT  2
 284
 285 static inline u32
 286 proto_get_router_id(struct proto_config *pc)
 287 {
 288   return pc->router_id ? pc->router_id : pc->global->router_id;
 289 }
 290
 291 static inline struct ea_list *
 292 rte_make_tmp_attrs(struct rte *rt, struct linpool *pool)
 293 {
 294   struct ea_list *(*mta)(struct rte *rt, struct linpool *pool);
 295   mta = rt->attrs->src->proto->make_tmp_attrs;
 296   return mta ? mta(rt, pool) : NULL;
 297 }
 298
 299 /* Moved from route.h to avoid dependency conflicts */
 300 static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_ahook, net, new, p->main_source); }
 301
 302 extern list active_proto_list;
 303
 304 /*
 305  *  Each protocol instance runs two different state machines:
 306  *
 307  *  [P] The protocol machine: (implemented inside protocol)
 308  *
 309  *              DOWN    ---->    START
 310  *                ^                |
 311  *                |                V
 312  *              STOP    <----     UP
 313  *
 314  *      States: DOWN    Protocol is down and it's waiting for the core
 315  *                      requesting protocol start.
 316  *              START   Protocol is waiting for connection with the rest
 317  *                      of the network and it's not willing to accept
 318  *                      packets. When it connects, it goes to UP state.
 319  *              UP      Protocol is up and running. When the network
 320  *                      connection breaks down or the core requests
 321  *                      protocol to be terminated, it goes to STOP state.
 322  *              STOP    Protocol is disconnecting from the network.
 323  *                      After it disconnects, it returns to DOWN state.
 324  *
 325  *      In:     start() Called in DOWN state to request protocol startup.
 326  *                      Returns new state: either UP or START (in this
 327  *                      case, the protocol will notify the core when it
 328  *                      finally comes UP).
 329  *              stop()  Called in START, UP or STOP state to request
 330  *                      protocol shutdown. Returns new state: either
 331  *                      DOWN or STOP (in this case, the protocol will
 332  *                      notify the core when it finally comes DOWN).
 333  *
 334  *      Out:    proto_notify_state() -- called by protocol instance when
 335  *                      it does any state transition not covered by
 336  *                      return values of start() and stop(). This includes
 337  *                      START->UP (delayed protocol startup), UP->STOP
 338  *                      (spontaneous shutdown) and STOP->DOWN (delayed
 339  *                      shutdown).
 340  */
 341
 342 #define PS_DOWN 0
 343 #define PS_START 1
 344 #define PS_UP 2
 345 #define PS_STOP 3
 346
 347 void proto_notify_state(struct proto *p, unsigned state);
 348
 349 /*
 350  *  [F] The feeder machine: (implemented in core routines)
 351  *
 352  *              HUNGRY    ---->   FEEDING
 353  *               ^                   |
 354  *               |                   V
 355  *              FLUSHING  <----   HAPPY
 356  *
 357  *      States: HUNGRY  Protocol either administratively down (i.e.,
 358  *                      disabled by the user) or temporarily down
 359  *                      (i.e., [P] is not UP)
 360  *              FEEDING The protocol came up and we're feeding it
 361  *                      initial routes. [P] is UP.
 362  *              HAPPY   The protocol is up and it's receiving normal
 363  *                      routing updates. [P] is UP.
 364  *              FLUSHING The protocol is down and we're removing its
 365  *                      routes from the table. [P] is STOP or DOWN.
 366  *
 367  *      Normal lifecycle of a protocol looks like:
 368  *
 369  *              HUNGRY/DOWN --> HUNGRY/START --> HUNGRY/UP -->
 370  *              FEEDING/UP --> HAPPY/UP --> FLUSHING/STOP|DOWN -->
 371  *              HUNGRY/STOP|DOWN --> HUNGRY/DOWN
 372  *
 373  *      Sometimes, protocol might switch from HAPPY/UP to FEEDING/UP
 374  *      if it wants to refeed the routes (for example BGP does so
 375  *      as a result of received ROUTE-REFRESH request).
 376  */
 377
 378 #define FS_HUNGRY       0
 379 #define FS_FEEDING      1       /* obsolete */
 380 #define FS_HAPPY        2
 381 #define FS_FLUSHING     3
 382
 383
 384 #define ES_DOWN         0
 385 #define ES_FEEDING      1
 386 #define ES_READY        2
 387
 388
 389
 390 /*
 391  *      Debugging flags
 392  */
 393
 394 #define D_STATES 1              /* [core] State transitions */
 395 #define D_ROUTES 2              /* [core] Routes passed by the filters */
 396 #define D_FILTERS 4             /* [core] Routes rejected by the filters */
 397 #define D_IFACES 8              /* [core] Interface events */
 398 #define D_EVENTS 16             /* Protocol events */
 399 #define D_PACKETS 32            /* Packets sent/received */
 400
 401 #ifndef PARSER
 402 #define TRACE(flags, msg, args...) \
 403   do { if (p->p.debug & flags) log(L_TRACE "%s: " msg, p->p.name , ## args ); } while(0)
 404 #endif
 405
 406
 407 /*
 408  *      MRTDump flags
 409  */
 410
 411 #define MD_STATES       1               /* Protocol state changes (BGP4MP_MESSAGE_AS4) */
 412 #define MD_MESSAGES     2               /* Protocol packets (BGP4MP_MESSAGE_AS4) */
 413
 414 /*
 415  *      Known unique protocol instances as referenced by config routines
 416  */
 417
 418 extern struct proto_config *cf_dev_proto;
 419
 420
 421 /*
 422  * Protocol limits
 423  */
 424
 425 #define PLD_RX          0       /* Receive limit */
 426 #define PLD_IN          1       /* Import limit */
 427 #define PLD_OUT         2       /* Export limit */
 428 #define PLD_MAX         3
 429
 430 #define PLA_WARN        1       /* Issue log warning */
 431 #define PLA_BLOCK       2       /* Block new routes */
 432 #define PLA_RESTART     4       /* Force protocol restart */
 433 #define PLA_DISABLE     5       /* Shutdown and disable protocol */
 434
 435 #define PLS_INITIAL     0       /* Initial limit state after protocol start */
 436 #define PLS_ACTIVE      1       /* Limit was hit */
 437 #define PLS_BLOCKED     2       /* Limit is active and blocking new routes */
 438
 439 struct proto_limit {
 440   u32 limit;                    /* Maximum number of prefixes */
 441   byte action;                  /* Action to take (PLA_*) */
 442   byte state;                   /* State of limit (PLS_*) */
 443 };
 444
 445 void proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32 rt_count);
 446 void proto_verify_limits(struct announce_hook *ah);
 447
 448 static inline void
 449 proto_reset_limit(struct proto_limit *l)
 450 {
 451   if (l)
 452     l->state = PLS_INITIAL;
 453 }
 454
 455
 456 /*
 457  *      Route Announcement Hook
 458  */
 459
 460 struct announce_hook {
 461   node n;
 462   struct rtable *table;
 463   struct proto *proto;
 464   struct filter *in_filter;             /* Input filter */
 465   struct filter *out_filter;            /* Output filter */
 466   struct proto_limit *rx_limit;         /* Receive limit (for in_keep_filtered) */
 467   struct proto_limit *in_limit;         /* Input limit */
 468   struct proto_limit *out_limit;        /* Output limit */
 469   struct proto_stats *stats;            /* Per-table protocol statistics */
 470   struct announce_hook *next;           /* Next hook for the same protocol */
 471   int in_keep_filtered;                 /* Routes rejected in import filter are kept */
 472 };
 473
 474 struct announce_hook *proto_add_announce_hook(struct proto *p, struct rtable *t, struct proto_stats *stats);
 475 struct announce_hook *proto_find_announce_hook(struct proto *p, struct rtable *t);
 476
 477 #endif