File: bgp.h

package info (click to toggle)
l2tpns 2.1.21-1.1
  • links: PTS
  • area: main
  • in suites: lenny, squeeze, wheezy
  • size: 820 kB
  • ctags: 1,621
  • sloc: ansic: 16,737; makefile: 160; sh: 142; perl: 139
file content (205 lines) | stat: -rw-r--r-- 7,073 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/* BGPv4 (RFC1771) */
/* $Id: bgp.h,v 1.5 2005/06/04 15:42:35 bodea Exp $ */

#ifndef __BGP_H__
#define __BGP_H__

#define BGP_MAX_PACKET_SIZE	4096
#define BGP_HOLD_TIME		180	/* seconds before peer times us out */
#define BGP_KEEPALIVE_TIME	60	/* seconds between messages */
#define BGP_STATE_TIME		60	/* state transition timeout in seconds */
#define BGP_MAX_RETRY		42	/* maximum number of times to retry */
#define BGP_RETRY_BACKOFF	60	/* number of seconds between retries,
					   cumulative */

#define BGP_METRIC		1	/* multi_exit_disc */
#define BGP_LOCAL_PREF		100	/* local preference value */

struct bgp_header {
    char marker[16];
    uint16_t len;
    uint8_t type;
} __attribute__ ((packed));

/* bgp_header.type */
#define BGP_MSG_OPEN		1
#define BGP_MSG_UPDATE		2
#define BGP_MSG_NOTIFICATION	3
#define BGP_MSG_KEEPALIVE	4

struct bgp_packet {
    struct bgp_header header;
    char data[BGP_MAX_PACKET_SIZE - sizeof(struct bgp_header)]; /* variable */
} __attribute__ ((packed));

struct bgp_data_open {
    uint8_t version;
#define BGP_VERSION	4
    uint16_t as;
    uint16_t hold_time;
    uint32_t identifier;
    uint8_t opt_len;
#define BGP_DATA_OPEN_SIZE	10 /* size of struct excluding opt_params */
    char opt_params[sizeof(((struct bgp_packet *)0)->data) - BGP_DATA_OPEN_SIZE]; /* variable */
} __attribute__ ((packed));

struct bgp_ip_prefix {
    uint8_t len;
    uint32_t prefix; /* variable */
} __attribute__ ((packed));

#define BGP_IP_PREFIX_SIZE(p) (1 + ((p).len / 8) + ((p).len % 8 != 0))

struct bgp_path_attr {
    uint8_t flags;
    uint8_t code;
    union {
	struct {
	    uint8_t len;
	    char value[29];		/* semi-random size, adequate for l2tpns */
	} __attribute__ ((packed)) s;	/* short */
	struct {
	    uint16_t len;
	    char value[28];
	} __attribute__ ((packed)) e;	/* extended */
    } data; /* variable */
} __attribute__ ((packed));

/* bgp_path_attr.flags (bitfields) */
#define BGP_PATH_ATTR_FLAG_OPTIONAL	(1 << 7)
#define BGP_PATH_ATTR_FLAG_TRANS	(1 << 6)
#define BGP_PATH_ATTR_FLAG_PARTIAL	(1 << 5)
#define BGP_PATH_ATTR_FLAG_EXTLEN	(1 << 4)

/* bgp_path_attr.code, ...value */
#define BGP_PATH_ATTR_CODE_ORIGIN		1	/* well-known, mandatory */
#  define BGP_PATH_ATTR_CODE_ORIGIN_IGP		  0
#  define BGP_PATH_ATTR_CODE_ORIGIN_EGP		  1
#  define BGP_PATH_ATTR_CODE_ORIGIN_INCOMPLETE	  2
#define BGP_PATH_ATTR_CODE_AS_PATH		2	/* well-known, mandatory */
#  define BGP_PATH_ATTR_CODE_AS_PATH_AS_SET	  1
#  define BGP_PATH_ATTR_CODE_AS_PATH_AS_SEQUENCE  2
#define BGP_PATH_ATTR_CODE_NEXT_HOP		3	/* well-known, mandatory */
#define BGP_PATH_ATTR_CODE_MULTI_EXIT_DISC	4	/* optional, non-transitive */
#define BGP_PATH_ATTR_CODE_LOCAL_PREF		5	/* well-known, discretionary */
#define BGP_PATH_ATTR_CODE_ATOMIC_AGGREGATE	6	/* well-known, discretionary */
#define BGP_PATH_ATTR_CODE_AGGREGATOR		7	/* optional, transitive */
#define BGP_PATH_ATTR_CODE_COMMUNITIES		8	/* optional, transitive (RFC1997) */

#define BGP_PATH_ATTR_SIZE(p) ((((p).flags & BGP_PATH_ATTR_FLAG_EXTLEN) \
    ? ((p).data.e.len + 1) : (p).data.s.len) + 3)

/* well known COMMUNITIES */
#define BGP_COMMUNITY_NO_EXPORT			0xffffff01	/* don't advertise outside confederation */
#define BGP_COMMUNITY_NO_ADVERTISE		0xffffff02	/* don't advertise to any peer */
#define BGP_COMMUNITY_NO_EXPORT_SUBCONFED	0xffffff03	/* don't advertise to any other AS */

struct bgp_data_notification {
    uint8_t error_code;
    uint8_t error_subcode;
    char data[sizeof(((struct bgp_packet *)0)->data) - 2]; /* variable */
} __attribute__ ((packed));

/* bgp_data_notification.error_code, .error_subcode */
#define BGP_ERR_HEADER			1
#  define BGP_ERR_HDR_NOT_SYNC		  1
#  define BGP_ERR_HDR_BAD_LEN		  2
#  define BGP_ERR_HDR_BAD_TYPE		  3
#define BGP_ERR_OPEN			2
#  define BGP_ERR_OPN_VERSION		  1
#  define BGP_ERR_OPN_BAD_AS		  2
#  define BGP_ERR_OPN_BAD_IDENT		  3
#  define BGP_ERR_OPN_UNSUP_PARAM	  4
#  define BGP_ERR_OPN_AUTH_FAILURE	  5
#  define BGP_ERR_OPN_HOLD_TIME		  6
#define BGP_ERR_UPDATE			3
#  define BGP_ERR_UPD_BAD_ATTR_LIST	  1
#  define BGP_ERR_UPD_UNKN_WK_ATTR	  2
#  define BGP_ERR_UPD_MISS_WK_ATTR	  3
#  define BGP_ERR_UPD_BAD_ATTR_FLAG	  4
#  define BGP_ERR_UPD_BAD_ATTR_LEN	  5
#  define BGP_ERR_UPD_BAD_ORIGIN	  6
#  define BGP_ERR_UPD_ROUTING_LOOP	  7
#  define BGP_ERR_UPD_BAD_NEXT_HOP	  8
#  define BGP_ERR_UPD_BAD_OPT_ATTR	  9
#  define BGP_ERR_UPD_BAD_NETWORK	  10
#  define BGP_ERR_UPD_BAD_AS_PATH	  11
#define BGP_ERR_HOLD_TIMER_EXP		4
#define BGP_ERR_FSM			5
#define BGP_ERR_CEASE			6

enum bgp_state {
    Disabled,				/* initial, or failed */
    Idle,				/* trying to connect */
    Connect,				/* connect issued */
    Active,				/* connected, waiting to send OPEN */
    OpenSent,				/* OPEN sent, waiting for peer OPEN */
    OpenConfirm,			/* KEEPALIVE sent, waiting for peer KEEPALIVE */
    Established,			/* established */
};

struct bgp_route_list {
    struct bgp_ip_prefix dest;
    struct bgp_route_list *next;
};

struct bgp_buf {
    struct bgp_packet packet;		/* BGP packet */
    size_t done;			/* bytes sent/recvd */
};

/* state */
struct bgp_peer {
    char name[32];			/* peer name */
    in_addr_t addr;			/* peer address */
    int as;				/* AS number */
    int sock;
    enum bgp_state state;		/* FSM state */
    enum bgp_state next_state;		/* next state after outbuf cleared */
    time_t state_time;			/* time of last state change */
    time_t keepalive_time;		/* time to send next keepalive */
    time_t retry_time;			/* time for connection retry */
    int retry_count;			/* connection retry count */
    int init_keepalive;			/* initial keepalive time */
    int init_hold;			/* initial hold time */
    int keepalive;			/* negotiated keepalive time */
    int hold;				/* negotiated hold time */
    time_t expire_time;			/* time next peer packet expected */
    int routing;			/* propagate routes */
    int update_routes;			/* UPDATE required */
    struct bgp_route_list *routes;	/* routes known by this peer */
    struct bgp_buf *outbuf;		/* pending output */
    struct bgp_buf *inbuf;		/* pending input */
    int cli_flag;			/* updates requested from CLI */
    char *path_attrs;			/* path attrs to send in UPDATE message */
    int path_attr_len;			/* length of path attrs */
    uint32_t events;			/* events to poll */
    struct event_data edata;		/* poll data */
};

/* bgp_peer.cli_flag */
#define BGP_CLI_SUSPEND		1
#define BGP_CLI_ENABLE		2
#define BGP_CLI_RESTART		3

extern struct bgp_peer *bgp_peers;
extern int bgp_configured;

/* actions */
int bgp_setup(int as);
int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive,
    int hold, int enable);

void bgp_stop(struct bgp_peer *peer);
void bgp_halt(struct bgp_peer *peer);
int bgp_restart(struct bgp_peer *peer);
int bgp_add_route(in_addr_t ip, in_addr_t mask);
int bgp_del_route(in_addr_t ip, in_addr_t mask);
void bgp_enable_routing(int enable);
int bgp_set_poll(void);
int bgp_process(uint32_t events[]);
char const *bgp_state_str(enum bgp_state state);

extern char const *cvs_id_bgp;

#endif /* __BGP_H__ */