protocol.h 5.87 KB
Newer Older
1 2 3
/*
 *	BIRD Internet Routing Daemon -- Protocols
 *
4
 *	(c) 1998--1999 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

15 16 17
struct iface;
struct rte;
struct neighbor;
18
struct rta;
19
struct network;
20 21 22
struct proto_config;
struct config;
struct proto;
23
struct event;
24

25 26 27 28 29
/*
 *	Routing Protocol
 */

struct protocol {
30
  node n;
31 32
  char *name;
  unsigned debug;			/* Default debugging flags */
33
  int priority;				/* Protocol priority (usually 0) */
34
  int name_counter;			/* Counter for automatic name generation */
35

36 37 38 39 40 41 42
  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 */
  int (*reconfigure)(struct proto *, struct proto_config *);	/* Try to reconfigure instance */
  void (*dump)(struct proto *);			/* Debugging dump */
  int (*start)(struct proto *);			/* Start the instance */
  int (*shutdown)(struct proto *);		/* Stop the instance */
43 44
};

45
void protos_build(void);
46 47 48
void protos_preconfig(struct config *);
void protos_postconfig(struct config *);
void protos_commit(struct config *);
49
void protos_start(void);
50
void protos_dump_all(void);
51
void protos_shutdown(void);
52 53

extern list protocol_list;
54 55 56 57 58

/*
 *	Known protocols
 */

59
extern struct protocol proto_device;
60
extern struct protocol proto_rip;
61
extern struct protocol proto_static;
Ondřej Filip's avatar
 
Ondřej Filip committed
62
extern struct protocol proto_ospf;
63 64 65 66 67

/*
 *	Routing Protocol Instance
 */

68 69 70 71 72 73
struct proto_config {
  node n;
  struct config *global;		/* Global configuration data */
  struct protocol *proto;		/* Protocol */
  char *name;
  unsigned debug, preference, disabled;	/* Generic parameters */
74
  struct filter *in_filter, *out_filter; /* Attached filters */
75 76 77 78

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

79
struct proto {
80
  node n;
81
  struct protocol *proto;		/* Protocol */
82 83
  struct proto_config *cf;		/* Configuration data */
  pool *pool;				/* Pool containing local objects */
84
  struct event *attn;			/* "Pay attention" event */
85

86
  char *name;				/* Name of this instance (== cf->name) */
87 88
  unsigned debug;			/* Debugging flags */
  unsigned preference;			/* Default route preference */
89
  unsigned disabled;			/* Manually disabled */
90 91
  unsigned proto_state;			/* Protocol state machine (see below) */
  unsigned core_state;			/* Core state machine (see below) */
92
  unsigned core_goal;			/* State we want to reach (see below) */
93

94
  void (*if_notify)(struct proto *, unsigned flags, struct iface *new, struct iface *old);
95
  void (*rt_notify)(struct proto *, struct network *net, struct rte *new, struct rte *old);
96
  void (*neigh_notify)(struct neighbor *neigh);
97

98
  int (*rte_better)(struct rte *, struct rte *);
99 100
  void (*rte_insert)(struct network *, struct rte *);
  void (*rte_remove)(struct network *, struct rte *);
101

102
  struct rtable *table;			/* Routing table we're connected to */
103 104 105
  struct filter *in_filter;		/* Input filter */
  struct filter *out_filter;		/* Output filter */

106 107 108
  /* Hic sunt protocol-specific data */
};

109 110 111
void proto_build(struct proto_config *);
void *proto_new(struct proto_config *, unsigned size);
void *proto_config_new(struct protocol *, unsigned size);
112

113
extern list proto_list;
114

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 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
/*
 *  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

190 191 192 193
/*
 *	Known unique protocol instances as referenced by config routines
 */

194
extern struct proto_config *cf_dev_proto;
195

196 197 198 199 200 201
/*
 *	Callback to sysdep code when shutdown is finished
 */

void protos_shutdown_notify(void);

202
#endif