From c01e37416d09a92bf838250a15fe99fdc48bc010 Mon Sep 17 00:00:00 2001 From: Martin Mares Date: Mon, 20 Mar 2000 21:50:17 +0000 Subject: Started work on BGP. Wrote main part of the connection handling code. --- proto/bgp/bgp.c | 260 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 259 insertions(+), 1 deletion(-) (limited to 'proto/bgp/bgp.c') diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c index 26e3906..40915a4 100644 --- a/proto/bgp/bgp.c +++ b/proto/bgp/bgp.c @@ -12,10 +12,20 @@ #include "nest/iface.h" #include "nest/protocol.h" #include "nest/route.h" +#include "nest/locks.h" #include "conf/conf.h" +#include "lib/socket.h" #include "bgp.h" +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); + static void bgp_rt_notify(struct proto *P, net *n, rte *new, rte *old, ea_list *tmpa) { @@ -29,18 +39,266 @@ bgp_init(struct proto_config *C) struct bgp_proto *p = (struct bgp_proto *) P; P->rt_notify = bgp_rt_notify; + p->cf = c; + p->local_as = c->local_as; + p->remote_as = c->remote_as; + p->is_internal = (c->local_as == c->remote_as); + p->conn.state = BS_IDLE; + p->incoming_conn.state = BS_IDLE; + p->local_id = C->global->router_id; return P; } +static void +bgp_close(struct bgp_proto *p) +{ + rem_node(&p->bgp_node); + ASSERT(bgp_counter); + bgp_counter--; + if (!bgp_counter) + { + rfree(bgp_listen_sk); + bgp_listen_sk = NULL; + } + /* FIXME: Automatic restart after errors? */ +} + +static void +bgp_reset(struct bgp_proto *p) +{ + bgp_close(p); + proto_notify_state(&p->p, PS_DOWN); +} + +static void +bgp_start_timer(timer *t, int value) +{ + /* FIXME: Randomize properly */ + /* FIXME: Check if anybody uses tm_start directly */ + tm_start(t, value); +} + +static int +bgp_rx(sock *sk, int size) +{ + DBG("BGP: Got %d bytes\n", size); + + return 1; /* Start from the beginning */ +} + +static void +bgp_send_open(struct bgp_conn *conn) +{ + DBG("BGP: Sending open\n"); + conn->sk->rx_hook = bgp_rx; + tm_stop(conn->connect_retry_timer); + /* FIXME */ + conn->state = BS_OPENSENT; +} + +static int +bgp_connected(sock *sk, int dummy) +{ + 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; + + DBG("BGP: Connect timeout, retrying\n"); + bgp_close_conn(conn); + bgp_connect(p); +} + +static void +bgp_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: + case BS_OPENSENT: + conn->state = BS_ACTIVE; + bgp_start_timer(conn->connect_retry_timer, conn->bgp->cf->connect_retry_time); + break; + case BS_OPENCONFIRM: + case BS_ESTABLISHED: + /* FIXME: Should close the connection and go to Idle state */ + default: + bug("bgp_err called in invalid state %d", conn->state); + } +} + +static int +bgp_incoming_connection(sock *sk, int dummy) +{ + node *n; + + DBG("BGP: Incoming connection from %I port %d\n", sk->daddr, sk->dport); + WALK_LIST(n, bgp_list) + { + struct bgp_proto *p = SKIP_BACK(struct bgp_proto, bgp_node, n); + if (ipa_equal(p->cf->remote_ip, sk->daddr) && sk->dport == BGP_PORT) + { + DBG("BGP: Authorized\n"); + if (p->incoming_conn.sk) + { + DBG("BGP: But one incoming connection already exists, how is that possible?\n"); + break; + } + bgp_setup_sk(p, &p->incoming_conn, sk); + bgp_send_open(&p->incoming_conn); + return 0; + } + } + DBG("BGP: Unauthorized\n"); + rfree(sk); + return 0; +} + +static void +bgp_setup_sk(struct bgp_proto *p, struct bgp_conn *conn, sock *s) +{ + timer *t; + + s->data = conn; + s->ttl = p->cf->multihop ? : 1; + s->rbsize = BGP_RX_BUFFER_SIZE; +#if 0 + s->tx_hook = bgp_tx; +#endif + s->err_hook = bgp_err; + s->tos = IP_PREC_INTERNET_CONTROL; + + conn->bgp = p; + conn->sk = 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->hook = bgp_hold_timeout; + t->data = p; + t = p->keepalive_timer = tm_new(p->p.pool); + t->hook = bgp_keepalive_timeout; + t->data = p; +#endif +} + +static void +bgp_close_conn(struct bgp_conn *conn) +{ + 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); + conn->sk = NULL; + conn->state = BS_IDLE; +} + +static void +bgp_connect(struct bgp_proto *p) /* Enter Connect state and start establishing connection */ +{ + sock *s; + struct bgp_conn *conn = &p->conn; + + DBG("BGP: Connecting\n"); + s = sk_new(p->p.pool); + s->type = SK_TCP_ACTIVE; + s->saddr = _MI(0x3ea80001); /* FIXME: Hack */ + s->daddr = p->cf->remote_ip; +#if 0 + s->sport = /* FIXME */ +#endif + s->dport = BGP_PORT; + s->rx_hook = bgp_connected; + bgp_setup_sk(p, conn, s); + conn->state = BS_CONNECT; + if (sk_open(s)) + { + bgp_err(s, 0); + return; + } + DBG("BGP: Waiting for connect success\n"); + bgp_start_timer(conn->connect_retry_timer, p->cf->connect_retry_time); +} + +static void +bgp_start_locked(struct object_lock *lock) +{ + struct bgp_proto *p = lock->data; + + DBG("BGP: Got lock\n"); + if (!bgp_counter++) + init_list(&bgp_list); + if (!bgp_listen_sk) + { + sock *s = sk_new(&root_pool); + DBG("BGP: Creating incoming socket\n"); + s->type = SK_TCP_PASSIVE; + s->sport = BGP_PORT; + s->tos = IP_PREC_INTERNET_CONTROL; + s->ttl = 1; + s->rbsize = BGP_RX_BUFFER_SIZE; + s->rx_hook = bgp_incoming_connection; + if (sk_open(s)) + { + log(L_ERR "Unable to open incoming BGP socket"); + rfree(s); + } + else + bgp_listen_sk = s; + } + add_tail(&bgp_list, &p->bgp_node); + bgp_connect(p); /* FIXME: Use neighbor cache for fast up/down transitions? */ +} + static int bgp_start(struct proto *P) { - return PS_UP; + struct bgp_proto *p = (struct bgp_proto *) P; + struct object_lock *lock; + + /* + * Before attempting to create the connection, we need to lock the + * port, so that are sure we're the only instance attempting to talk + * with that neighbor. + */ + + DBG("BGP: Startup. Acquiring lock.\n"); + lock = p->lock = olock_new(P->pool); + lock->addr = p->cf->remote_ip; + lock->type = OBJLOCK_TCP; + lock->port = BGP_PORT; + lock->iface = NULL; + lock->hook = bgp_start_locked; + lock->data = p; + olock_acquire(lock); + return PS_START; } static int bgp_shutdown(struct proto *P) { + struct bgp_proto *p = (struct bgp_proto *) P; + + DBG("BGP: Explicit shutdown\n"); + + bgp_close(p); return PS_DOWN; } -- cgit v1.2.3