Commit 3fdbafb6 authored by Martin Mareš's avatar Martin Mareš

More BGP. This time it connects, but the state machine still isn't complete.

parent 320f4173
......@@ -22,7 +22,6 @@ static sock *bgp_listen_sk; /* Global listening socket */
static int bgp_counter; /* Number of protocol instances using the listening socket */
static list bgp_list; /* List of active BGP instances */
static void bgp_close_conn(struct bgp_conn *conn);
static void bgp_connect(struct bgp_proto *p);
static void bgp_setup_sk(struct bgp_proto *p, struct bgp_conn *conn, sock *s);
......@@ -63,19 +62,20 @@ bgp_close(struct bgp_proto *p)
/* FIXME: Automatic restart after errors? */
}
static void
static void /* FIXME: Nobody uses */
bgp_reset(struct bgp_proto *p)
{
bgp_close(p);
proto_notify_state(&p->p, PS_DOWN);
}
static void
void
bgp_start_timer(timer *t, int value)
{
/* FIXME: Randomize properly */
/* FIXME: Check if anybody uses tm_start directly */
tm_start(t, value);
if (value)
tm_start(t, value);
}
static void
......@@ -86,36 +86,34 @@ bgp_send_open(struct bgp_conn *conn)
tm_stop(conn->connect_retry_timer);
bgp_schedule_packet(conn, PKT_OPEN);
conn->state = BS_OPENSENT;
bgp_start_timer(conn->hold_timer, conn->bgp->cf->initial_hold_time);
}
static int
bgp_connected(sock *sk, int dummy)
static void
bgp_connected(sock *sk)
{
struct bgp_conn *conn = sk->data;
DBG("BGP: Connected\n");
bgp_send_open(conn);
return 0;
}
static void
bgp_connect_timeout(timer *t)
{
struct bgp_proto *p = t->data;
struct bgp_conn *conn = &p->conn;
struct bgp_conn *conn = t->data;
DBG("BGP: Connect timeout, retrying\n");
bgp_close_conn(conn);
bgp_connect(p);
bgp_connect(conn->bgp);
}
static void
bgp_err(sock *sk, int err)
bgp_sock_err(sock *sk, int err)
{
struct bgp_conn *conn = sk->data;
DBG("BGP: Socket error %d in state %d\n", err, conn->state);
sk->type = SK_DELETED; /* FIXME: Need to do this always! */
switch (conn->state)
{
case BS_CONNECT:
......@@ -125,10 +123,11 @@ bgp_err(sock *sk, int err)
break;
case BS_OPENCONFIRM:
case BS_ESTABLISHED:
/* FIXME: Should close the connection and go to Idle state */
/* FIXME */
default:
bug("bgp_err called in invalid state %d", conn->state);
bug("bgp_sock_err called in invalid state %d", conn->state);
}
bgp_close_conn(conn);
}
static int
......@@ -158,6 +157,24 @@ bgp_incoming_connection(sock *sk, int dummy)
return 0;
}
static void
bgp_hold_timeout(timer *t)
{
struct bgp_conn *conn = t->data;
DBG("BGP: Hold timeout, closing connection\n"); /* FIXME: Check states? */
bgp_error(conn, 4, 0, 0, 0);
}
static void
bgp_keepalive_timeout(timer *t)
{
struct bgp_conn *conn = t->data;
DBG("BGP: Keepalive timer\n");
bgp_schedule_packet(conn, PKT_KEEPALIVE);
}
static void
bgp_setup_sk(struct bgp_proto *p, struct bgp_conn *conn, sock *s)
{
......@@ -168,7 +185,7 @@ bgp_setup_sk(struct bgp_proto *p, struct bgp_conn *conn, sock *s)
s->rbsize = BGP_RX_BUFFER_SIZE;
s->tbsize = BGP_TX_BUFFER_SIZE;
s->tx_hook = bgp_tx;
s->err_hook = bgp_err;
s->err_hook = bgp_sock_err;
s->tos = IP_PREC_INTERNET_CONTROL;
conn->bgp = p;
......@@ -177,27 +194,27 @@ bgp_setup_sk(struct bgp_proto *p, struct bgp_conn *conn, sock *s)
t = conn->connect_retry_timer = tm_new(p->p.pool);
t->hook = bgp_connect_timeout;
t->data = p;
#if 0
t = p->hold_timer = tm_new(p->p.pool);
t->data = conn;
t = conn->hold_timer = tm_new(p->p.pool);
t->hook = bgp_hold_timeout;
t->data = p;
t = p->keepalive_timer = tm_new(p->p.pool);
t->data = conn;
t = conn->keepalive_timer = tm_new(p->p.pool);
t->hook = bgp_keepalive_timeout;
t->data = p;
#endif
t->data = conn;
}
static void
void
bgp_close_conn(struct bgp_conn *conn)
{
DBG("BGP: Closing connection\n");
conn->packets_to_send = 0;
rfree(conn->connect_retry_timer);
conn->connect_retry_timer = NULL;
rfree(conn->keepalive_timer);
conn->keepalive_timer = NULL;
rfree(conn->hold_timer);
conn->hold_timer = NULL;
rfree(conn->sk);
sk_close(conn->sk);
conn->sk = NULL;
conn->state = BS_IDLE;
}
......@@ -217,12 +234,12 @@ bgp_connect(struct bgp_proto *p) /* Enter Connect state and start establishing c
s->sport = /* FIXME */
#endif
s->dport = BGP_PORT;
s->rx_hook = bgp_connected;
bgp_setup_sk(p, conn, s);
s->tx_hook = bgp_connected;
conn->state = BS_CONNECT;
if (sk_open(s))
{
bgp_err(s, 0);
bgp_sock_err(s, 0);
return;
}
DBG("BGP: Waiting for connect success\n");
......@@ -294,6 +311,21 @@ bgp_shutdown(struct proto *P)
return PS_DOWN;
}
void
bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, unsigned data, unsigned len)
{
DBG("BGP: Error %d,%d,%d,%d\n", code, subcode, data, len); /* FIXME: Better messages */
if (c->error_flag)
return;
c->error_flag = 1;
c->notify_code = code;
c->notify_subcode = subcode;
c->notify_arg = data;
c->notify_arg_size = len;
proto_notify_state(&c->bgp->p, PS_STOP);
bgp_schedule_packet(c, PKT_NOTIFICATION);
}
void
bgp_check(struct bgp_config *c)
{
......
......@@ -14,9 +14,9 @@ struct bgp_config {
unsigned int local_as, remote_as;
ip_addr remote_ip;
int multihop; /* Number of hops if multihop */
int connect_retry_time;
int hold_time;
int keepalive_time;
unsigned connect_retry_time;
unsigned hold_time, initial_hold_time;
unsigned keepalive_time;
};
struct bgp_conn {
......@@ -26,20 +26,20 @@ struct bgp_conn {
struct timer *connect_retry_timer;
struct timer *hold_timer;
struct timer *keepalive_timer;
unsigned int packets_to_send; /* Bitmap of packet types to be sent */
unsigned int notify_code, notify_subcode, notify_arg, notify_arg_size;
unsigned int error_flag; /* Error state, ignore all input */
int packets_to_send; /* Bitmap of packet types to be sent */
int notify_code, notify_subcode, notify_arg, notify_arg_size;
int error_flag; /* Error state, ignore all input */
unsigned hold_time, keepalive_time; /* Times calculated from my and neighbor's requirements */
};
struct bgp_proto {
struct proto p;
struct bgp_config *cf; /* Shortcut to BGP configuration */
node bgp_node; /* Node in global BGP protocol list */
int local_as, remote_as;
unsigned local_as, remote_as;
int is_internal; /* Internal BGP connection (local_as == remote_as) */
u32 local_id; /* BGP identifier of this router */
u32 remote_id; /* BGP identifier of the neighbor */
int hold_time; /* Hold time calculated from my and neighbor's requirements */
struct bgp_conn conn; /* Our primary connection */
struct bgp_conn incoming_conn; /* Incoming connection we have neither accepted nor rejected yet */
struct object_lock *lock; /* Lock for neighbor connection */
......@@ -52,7 +52,10 @@ struct bgp_proto {
#define BGP_RX_BUFFER_SIZE 4096
#define BGP_TX_BUFFER_SIZE BGP_MAX_PACKET_LENGTH
void bgp_start_timer(struct timer *t, int value);
void bgp_check(struct bgp_config *c);
void bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, unsigned data, unsigned len);
void bgp_close_conn(struct bgp_conn *conn);
/* attrs.c */
......
......@@ -15,7 +15,7 @@ CF_HDR
CF_DECLS
CF_KEYWORDS(BGP, LOCAL, NEIGHBOR, AS, HOLD, TIME, CONNECT, RETRY, KEEPALIVE,
MULTIHOP)
MULTIHOP, STARTUP)
CF_GRAMMAR
......@@ -26,7 +26,7 @@ bgp_proto_start: proto_start BGP {
this_proto->preference = DEF_PREF_BGP;
BGP_CFG->hold_time = 240;
BGP_CFG->connect_retry_time = 120;
BGP_CFG->keepalive_time = 30;
BGP_CFG->initial_hold_time = 300;
}
;
......@@ -43,6 +43,7 @@ bgp_proto:
BGP_CFG->remote_as = $5;
}
| bgp_proto HOLD TIME NUM ';' { BGP_CFG->hold_time = $4; }
| bgp_proto STARTUP HOLD TIME NUM ';' { BGP_CFG->initial_hold_time = $5; }
| bgp_proto CONNECT RETRY TIME NUM ';' { BGP_CFG->connect_retry_time = $5; }
| bgp_proto KEEPALIVE TIME NUM ';' { BGP_CFG->connect_retry_time = $4; }
| bgp_proto MULTIHOP NUM ';' { BGP_CFG->multihop = $3; }
......
......@@ -53,6 +53,7 @@ static byte *
bgp_create_update(struct bgp_conn *conn, byte *buf)
{
DBG("BGP: Sending update\n");
bug("Don't know how to create updates");
}
......@@ -64,7 +65,7 @@ bgp_create_header(byte *buf, unsigned int len, unsigned int type)
buf[18] = type;
}
static void
static int
bgp_fire_tx(struct bgp_conn *conn)
{
unsigned int s = conn->packets_to_send;
......@@ -76,8 +77,8 @@ bgp_fire_tx(struct bgp_conn *conn)
if (s & (1 << PKT_SCHEDULE_CLOSE))
{
conn->packets_to_send = 0;
bug("Scheduled close"); /* FIXME */
bgp_close_conn(conn);
return 0;
}
if (s & (1 << PKT_NOTIFICATION))
{
......@@ -91,6 +92,7 @@ bgp_fire_tx(struct bgp_conn *conn)
type = PKT_KEEPALIVE;
end = pkt; /* Keepalives carry no data */
DBG("BGP: Sending keepalive\n");
bgp_start_timer(conn->keepalive_timer, conn->keepalive_time);
}
else if (s & (1 << PKT_OPEN))
{
......@@ -105,14 +107,14 @@ bgp_fire_tx(struct bgp_conn *conn)
if (!end)
{
conn->packets_to_send = 0;
return;
return 0;
}
}
else
return;
return 0;
conn->packets_to_send = s;
bgp_create_header(buf, end - buf, type);
sk_send(sk, end - buf);
return sk_send(sk, end - buf);
}
void
......@@ -120,8 +122,9 @@ bgp_schedule_packet(struct bgp_conn *conn, int type)
{
DBG("BGP: Scheduling packet type %d\n", type);
conn->packets_to_send |= 1 << type;
if (conn->sk->tpos != conn->sk->tbuf)
bgp_fire_tx(conn);
if (conn->sk->tpos == conn->sk->tbuf)
while (bgp_fire_tx(conn))
;
}
void
......@@ -130,7 +133,124 @@ bgp_tx(sock *sk)
struct bgp_conn *conn = sk->data;
DBG("BGP: TX hook\n");
bgp_fire_tx(conn);
while (bgp_fire_tx(conn))
;
}
static void
bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
{
struct bgp_proto *p = conn->bgp;
struct bgp_config *cf = p->cf;
unsigned as, hold;
u32 id;
/* Check state */
if (conn->state != BS_OPENSENT)
{ bgp_error(conn, 5, 0, conn->state, 0); }
/* Check message contents */
if (len < 29 || len != 29 + pkt[28])
{ bgp_error(conn, 1, 2, len, 2); return; }
if (pkt[19] != BGP_VERSION)
{ bgp_error(conn, 2, 1, pkt[19], 2); return; }
as = get_u16(pkt+20);
hold = get_u16(pkt+22);
id = get_u32(pkt+24);
DBG("BGP: OPEN as=%d hold=%d id=%08x\n", as, hold, id);
if (cf->remote_as && as != p->remote_as)
{ bgp_error(conn, 2, 2, as, 0); return; }
if (hold > 0 && hold < 3)
{ bgp_error(conn, 2, 6, hold, 0); return; }
p->remote_id = id;
if (pkt[28]) /* Currently we support no optional parameters */
{ bgp_error(conn, 2, 4, pkt[28], 0); return; }
if (!id || id == 0xffffffff || id == p->local_id)
{ bgp_error(conn, 2, 3, id, 0); return; }
/* FIXME: What to do with the other connection??? */
ASSERT(conn == &p->conn);
/* Update our local variables */
if (hold < p->cf->hold_time)
conn->hold_time = hold;
else
conn->hold_time = p->cf->hold_time;
conn->keepalive_time = p->cf->keepalive_time ? : conn->hold_time / 3;
p->remote_as = as;
p->remote_id = id;
DBG("BGP: Hold timer set to %d, keepalive to %d, AS to %d, ID to %x\n", conn->hold_time, conn->keepalive_time, p->remote_as, p->remote_id);
bgp_schedule_packet(conn, PKT_KEEPALIVE);
bgp_start_timer(conn->hold_timer, conn->hold_time);
conn->state = BS_OPENCONFIRM;
}
static void
bgp_rx_update(struct bgp_conn *conn, byte *pkt, int len)
{
if (conn->state != BS_ESTABLISHED)
{ bgp_error(conn, 5, 0, conn->state, 0); return; }
bgp_start_timer(conn->hold_timer, conn->hold_time);
DBG("BGP: UPDATE (ignored)\n");
}
static void
bgp_rx_notification(struct bgp_conn *conn, byte *pkt, int len)
{
unsigned arg;
if (len < 21)
{
bgp_error(conn, 1, 2, len, 2);
return;
}
switch (len)
{
case 21: arg = 0; break;
case 22: arg = pkt[21]; break;
case 23: arg = get_u16(pkt+21); break;
case 25: arg = get_u32(pkt+23); break;
default: DBG("BGP: NOTIFICATION with too much data\n"); /* FIXME */ arg = 0;
}
DBG("BGP: NOTIFICATION %d.%d %08x\n", pkt[19], pkt[20], arg); /* FIXME: Better reporting */
conn->error_flag = 1;
proto_notify_state(&conn->bgp->p, PS_STOP);
bgp_schedule_packet(conn, PKT_SCHEDULE_CLOSE);
}
static void
bgp_rx_keepalive(struct bgp_conn *conn, byte *pkt, unsigned len)
{
DBG("BGP: KEEPALIVE\n");
bgp_start_timer(conn->hold_timer, conn->hold_time);
switch (conn->state)
{
case BS_OPENCONFIRM:
DBG("BGP: UP!!!\n");
conn->state = BS_ESTABLISHED;
proto_notify_state(&conn->bgp->p, PS_UP);
break;
case BS_ESTABLISHED:
break;
default:
bgp_error(conn, 5, 0, conn->state, 0);
}
}
static void
bgp_rx_packet(struct bgp_conn *conn, byte *pkt, unsigned len)
{
DBG("BGP: Got packet %02x (%d bytes)\n", pkt[18], len);
switch (pkt[18])
{
case PKT_OPEN: return bgp_rx_open(conn, pkt, len);
case PKT_UPDATE: return bgp_rx_update(conn, pkt, len);
case PKT_NOTIFICATION: return bgp_rx_notification(conn, pkt, len);
case PKT_KEEPALIVE: return bgp_rx_keepalive(conn, pkt, len);
default: bgp_error(conn, 1, 3, pkt[18], 1);
}
}
int
......@@ -139,13 +259,33 @@ bgp_rx(sock *sk, int size)
struct bgp_conn *conn = sk->data;
byte *pkt_start = sk->rbuf;
byte *end = pkt_start + size;
unsigned i, len;
DBG("BGP: RX hook: Got %d bytes\n", size);
while (end >= pkt_start + BGP_HEADER_LENGTH)
{
if (conn->error_flag)
return 1;
bug("Incoming packets not handled"); /* FIXME */
{
DBG("BGP: Error, dropping input\n");
return 1;
}
for(i=0; i<16; i++)
if (pkt_start[i] != 0xff)
{
bgp_error(conn, 1, 1, 0, 0);
break;
}
len = get_u16(pkt_start+16);
if (len < BGP_HEADER_LENGTH || len > BGP_MAX_PACKET_LENGTH)
{
bgp_error(conn, 1, 2, len, 2);
break;
}
if (end >= pkt_start + len)
{
bgp_rx_packet(conn, pkt_start, len);
pkt_start += len;
}
}
if (pkt_start != sk->rbuf)
{
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment