protocol.h 8.88 KB
Newer Older
1 2 3
/*
 *	BIRD Internet Routing Daemon -- Protocols
 *
4
 *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
5 6 7 8 9 10 11
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

#ifndef _BIRD_PROTOCOL_H_
#define _BIRD_PROTOCOL_H_

12
#include "lib/lists.h"
13
#include "lib/resource.h"
14
#include "lib/timer.h"
15

16
struct iface;
17
struct ifa;
18 19
struct rte;
struct neighbor;
20
struct rta;
21
struct network;
22 23 24
struct proto_config;
struct config;
struct proto;
25
struct event;
26
struct ea_list;
27
struct symbol;
28

29 30 31 32 33
/*
 *	Routing Protocol
 */

struct protocol {
34
  node n;
35
  char *name;
36
  char *template;			/* Template for automatic generation of names */
37
  int name_counter;			/* Counter for automatic name generation */
38

39 40 41
  void (*preconfig)(struct protocol *, struct config *);	/* Just before configuring */
  void (*postconfig)(struct proto_config *);			/* After configuring each instance */
  struct proto * (*init)(struct proto_config *);		/* Create new instance */
42
  int (*reconfigure)(struct proto *, struct proto_config *);	/* Try to reconfigure instance, returns success */
43
  void (*dump)(struct proto *);			/* Debugging dump */
44
  void (*dump_attrs)(struct rte *);		/* Dump protocol-dependent attributes */
45 46
  int (*start)(struct proto *);			/* Start the instance */
  int (*shutdown)(struct proto *);		/* Stop the instance */
47
  void (*get_status)(struct proto *, byte *buf); /* Get instance status (for `show protocols' command) */
48 49
  void (*get_route_info)(struct rte *, byte *buf); /* Get route information (for `show route' command) */
  void (*show_route_data)(struct rte *);	/* Print verbose route information (`show route' again) */
50 51
};

52
void protos_build(void);
53 54
void protos_preconfig(struct config *);
void protos_postconfig(struct config *);
55
void protos_commit(struct config *new, struct config *old, int force_restart);
56
void protos_dump_all(void);
57 58

extern list protocol_list;
59 60 61 62 63

/*
 *	Known protocols
 */

Martin Mareš's avatar
Martin Mareš committed
64 65 66
extern struct protocol
  proto_device, proto_rip, proto_static,
  proto_ospf, proto_pipe, proto_bgp;
67 68 69 70 71

/*
 *	Routing Protocol Instance
 */

72 73 74
struct proto_config {
  node n;
  struct config *global;		/* Global configuration data */
75 76
  struct protocol *protocol;		/* Protocol */
  struct proto *proto;			/* Instance we've created */
77 78
  char *name;
  unsigned debug, preference, disabled;	/* Generic parameters */
79
  struct rtable_config *table;		/* Table we're attached to */
80
  struct filter *in_filter, *out_filter; /* Attached filters */
81 82 83 84

  /* Protocol-specific data follow... */
};

85
struct proto {
86 87
  node n;				/* Node in *_proto_list */
  node glob_node;			/* Node in global proto_list */
88
  struct protocol *proto;		/* Protocol */
89
  struct proto_config *cf;		/* Configuration data */
90
  struct proto_config *cf_new;		/* Configuration we want to switch to after shutdown (NULL=delete) */
91
  pool *pool;				/* Pool containing local objects */
92
  struct event *attn;			/* "Pay attention" event */
93

94
  char *name;				/* Name of this instance (== cf->name) */
95 96
  unsigned debug;			/* Debugging flags */
  unsigned preference;			/* Default route preference */
97
  int min_scope;			/* Minimal route scope accepted */
98
  unsigned disabled;			/* Manually disabled */
99 100
  unsigned proto_state;			/* Protocol state machine (see below) */
  unsigned core_state;			/* Core state machine (see below) */
101
  unsigned core_goal;			/* State we want to reach (see below) */
102
  unsigned reconfiguring;		/* We're shutting down due to reconfiguration */
103
  u32 hash_key;				/* Random key used for hashing of neighbors */
104
  bird_clock_t last_state_change;	/* Time of last state transition */
105

106 107 108 109
  /*
   *	General protocol hooks:
   *
   *	   if_notify	Notify protocol about interface state changes.
110
   *	   ifa_notify	Notify protocol about interface address changes.
111 112 113 114 115 116 117 118 119 120
   *	   rt_notify	Notify protocol about routing table updates.
   *	   neigh_notify	Notify protocol about neighbor cache events.
   *	   make_tmp_attrs  Construct ea_list from private attrs stored in rte.
   *	   store_tmp_attrs Store private attrs back to the rte.
   *	   import_control  Called as the first step of the route importing process.
   *			It can construct a new rte, add private attributes and
   *			decide whether the route shall be imported: 1=yes, -1=no,
   *			0=process it through the import filter set by the user.
   */

121 122
  void (*if_notify)(struct proto *, unsigned flags, struct iface *i);
  void (*ifa_notify)(struct proto *, unsigned flags, struct ifa *a);
123
  void (*rt_notify)(struct proto *, struct network *net, struct rte *new, struct rte *old, struct ea_list *tmpa);
124
  void (*neigh_notify)(struct neighbor *neigh);
125 126 127 128 129 130 131 132 133 134 135
  struct ea_list *(*make_tmp_attrs)(struct rte *rt, struct linpool *pool);
  void (*store_tmp_attrs)(struct rte *rt, struct ea_list *attrs);
  int (*import_control)(struct proto *, struct rte **rt, struct ea_list **attrs, struct linpool *pool);

  /*
   *	Routing entry hooks (called only for rte's belonging to this protocol):
   *
   *	   rte_better	Compare two rte's and decide which one is better (1=first, 0=second).
   *	   rte_insert	Called whenever a rte is inserted to a routing table.
   *	   rte_remove	Called whenever a rte is removed from the routing table.
   */
136

137
  int (*rte_better)(struct rte *, struct rte *);
138 139
  void (*rte_insert)(struct network *, struct rte *);
  void (*rte_remove)(struct network *, struct rte *);
140

141
  struct rtable *table;			/* Our primary routing table */
142 143
  struct filter *in_filter;		/* Input filter */
  struct filter *out_filter;		/* Output filter */
144
  struct announce_hook *ahooks;		/* Announcement hooks for this protocol */
145

146 147 148
  /* Hic sunt protocol-specific data */
};

149 150 151
void proto_build(struct proto_config *);
void *proto_new(struct proto_config *, unsigned size);
void *proto_config_new(struct protocol *, unsigned size);
152

153
void proto_show(struct symbol *, int);
154
struct proto *proto_get_named(struct symbol *, struct protocol *);
155
void proto_xxable(char *, int);
156
void proto_debug(char *, unsigned int);
157

158
extern list active_proto_list;
159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
/*
 *  Each protocol instance runs two different state machines:
 *
 *  [P] The protocol machine: (implemented inside protocol)
 *
 *		DOWN    ---->    START
 *		  ^		   |
 *		  |		   V
 *		STOP    <----     UP
 *
 *	States:	DOWN	Protocol is down and it's waiting for the core
 *			requesting protocol start.
 *		START	Protocol is waiting for connection with the rest
 *			of the network and it's not willing to accept
 *			packets. When it connects, it goes to UP state.
 *		UP	Protocol is up and running. When the network
 *			connection breaks down or the core requests
 *			protocol to be terminated, it goes to STOP state.
 *		STOP	Protocol is disconnecting from the network.
 *			After it disconnects, it returns to DOWN state.
 *
 *	In:	start()	Called in DOWN state to request protocol startup.
 *			Returns new state: either UP or START (in this
 *			case, the protocol will notify the core when it
 *			finally comes UP).
 *		stop()	Called in START, UP or STOP state to request
 *			protocol shutdown. Returns new state: either
 *			DOWN or STOP (in this case, the protocol will
 *			notify the core when it finally comes DOWN).
 *
 *	Out:	proto_notify_state() -- called by protocol instance when
 *			it does any state transition not covered by
 *			return values of start() and stop(). This includes
 *			START->UP (delayed protocol startup), UP->STOP
 *			(spontaneous shutdown) and STOP->DOWN (delayed
 *			shutdown).
 */

#define PS_DOWN 0
#define PS_START 1
#define PS_UP 2
#define PS_STOP 3

void proto_notify_state(struct proto *p, unsigned state);

/*
 *  [F] The feeder machine: (implemented in core routines)
 *
 *		HUNGRY    ---->   FEEDING
 *		 ^		     |
 *		 | 		     V
 *		FLUSHING  <----   HAPPY
 *
 *	States:	HUNGRY	Protocol either administratively down (i.e.,
 *			disabled by the user) or temporarily down
 *			(i.e., [P] is not UP)
 *		FEEDING	The protocol came up and we're feeding it
 *			initial routes. [P] is UP.
 *		HAPPY	The protocol is up and it's receiving normal
 *			routing updates. [P] is UP.
 *		FLUSHING The protocol is down and we're removing its
 *			routes from the table. [P] is STOP or DOWN.
 *
 *	Normal lifecycle of a protocol looks like:
 *
 *		HUNGRY/DOWN --> HUNGRY/START --> HUNGRY/UP -->
 *		FEEDING/UP --> HAPPY/UP --> FLUSHING/STOP|DOWN -->
 *		HUNGRY/STOP|DOWN --> HUNGRY/DOWN
 */

#define FS_HUNGRY 0
#define FS_FEEDING 1
#define FS_HAPPY 2
#define FS_FLUSHING 3

235 236 237 238 239 240
/*
 *	Debugging flags
 */

#define D_STATES 1		/* [core] State transitions */
#define D_ROUTES 2		/* [core] Routes passed by the filters */
241 242 243 244
#define D_FILTERS 4		/* [core] Routes rejected by the filters */
#define D_IFACES 8		/* [core] Interface events */
#define D_EVENTS 16		/* Protocol events */
#define D_PACKETS 32		/* Packets sent/received */
245

246 247 248 249
/*
 *	Known unique protocol instances as referenced by config routines
 */

250
extern struct proto_config *cf_dev_proto;
251

252 253 254 255 256 257 258 259 260 261 262 263 264
/*
 *	Route Announcement Hook
 */

struct announce_hook {
  node n;
  struct rtable *table;
  struct proto *proto;
  struct announce_hook *next;		/* Next hook for the same protocol */
};

struct announce_hook *proto_add_announce_hook(struct proto *, struct rtable *);

265
#endif