From 93e868c730dc0b1825b2a685e0b066c051b1cb07 Mon Sep 17 00:00:00 2001 From: Ondrej Zajicek Date: Sun, 13 Mar 2011 11:33:50 +0100 Subject: Implements Router Advertisement protocol. --- proto/radv/radv.c | 329 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 proto/radv/radv.c (limited to 'proto/radv/radv.c') diff --git a/proto/radv/radv.c b/proto/radv/radv.c new file mode 100644 index 0000000..01cb689 --- /dev/null +++ b/proto/radv/radv.c @@ -0,0 +1,329 @@ +/* + * BIRD -- Router Advertisement + * + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + + +#include +#include "radv.h" + +/** + * DOC: Router Advertisements + * + * The RAdv protocol is implemented in two files: |radv.c| containing + * the interface with BIRD core and the protocol logic and |packets.c| + * handling low level protocol stuff (RX, TX and packet formats). + * The protocol does not import or export any routes. + * + * The RAdv is structured in the usual way - for each handled interface + * there is a structure &radv_iface that contains a state related to + * that interface together with its resources (a socket, a timer). + * There is also a prepared RA stored in a TX buffer of the socket + * associated with an iface. These iface structures are created + * and removed according to iface events from BIRD core handled by + * radv_if_notify() callback. + * + * The main logic of RAdv consists of two functions: + * radv_iface_notify(), which processes asynchronous events (specified + * by RA_EV_* codes), and radv_timer(), which triggers sending RAs and + * computes the next timeout. + */ + +static void +radv_timer(timer *tm) +{ + struct radv_iface *ifa = tm->data; + struct proto_radv *ra = ifa->ra; + + RADV_TRACE(D_EVENTS, "Timer fired on %s", ifa->iface->name); + + radv_send_ra(ifa, 0); + + /* Update timer */ + ifa->last = now; + unsigned after = ifa->cf->min_ra_int; + after += random() % (ifa->cf->max_ra_int - ifa->cf->min_ra_int + 1); + + if (ifa->initial) + ifa->initial--; + + if (ifa->initial) + after = MIN(after, MAX_INITIAL_RTR_ADVERT_INTERVAL); + + tm_start(ifa->timer, after); +} + +static char* ev_name[] = { NULL, "Init", "Change", "RS" }; + +void +radv_iface_notify(struct radv_iface *ifa, int event) +{ + struct proto_radv *ra = ifa->ra; + + if (!ifa->sk) + return; + + RADV_TRACE(D_EVENTS, "Event %s on %s", ev_name[event], ifa->iface->name); + + switch (event) + { + case RA_EV_CHANGE: + ifa->plen = 0; + case RA_EV_INIT: + ifa->initial = MAX_INITIAL_RTR_ADVERTISEMENTS; + break; + + case RA_EV_RS: + break; + } + + /* Update timer */ + unsigned delta = now - ifa->last; + unsigned after = 0; + + if (delta < ifa->cf->min_delay) + after = ifa->cf->min_delay - delta; + + tm_start(ifa->timer, after); +} + +static struct radv_iface * +radv_iface_find(struct proto_radv *ra, struct iface *what) +{ + struct radv_iface *ifa; + + WALK_LIST(ifa, ra->iface_list) + if (ifa->iface == what) + return ifa; + + return NULL; +} + +static void +radv_iface_add(struct object_lock *lock) +{ + struct radv_iface *ifa = lock->data; + struct proto_radv *ra = ifa->ra; + + if (! radv_sk_open(ifa)) + { + log(L_ERR "%s: Socket open failed on interface %s", ra->p.name, ifa->iface->name); + return; + } + + radv_iface_notify(ifa, RA_EV_INIT); +} + +static inline struct ifa * +find_lladdr(struct iface *iface) +{ + struct ifa *a; + WALK_LIST(a, iface->addrs) + if (a->scope == SCOPE_LINK) + return a; + + return NULL; +} + +static void +radv_iface_new(struct proto_radv *ra, struct iface *iface, struct radv_iface_config *cf) +{ + pool *pool = ra->p.pool; + struct radv_iface *ifa; + + RADV_TRACE(D_EVENTS, "Adding interface %s", iface->name); + + ifa = mb_allocz(pool, sizeof(struct radv_iface)); + ifa->ra = ra; + ifa->cf = cf; + ifa->iface = iface; + + add_tail(&ra->iface_list, NODE ifa); + + ifa->addr = find_lladdr(iface); + if (!ifa->addr) + { + log(L_ERR "%s: Cannot find link-locad addr on interface %s", ra->p.name, iface->name); + return; + } + + timer *tm = tm_new(pool); + tm->hook = radv_timer; + tm->data = ifa; + tm->randomize = 0; + tm->recurrent = 0; + ifa->timer = tm; + + struct object_lock *lock = olock_new(pool); + lock->addr = IPA_NONE; + lock->type = OBJLOCK_IP; + lock->port = ICMPV6_PROTO; + lock->iface = iface; + lock->data = ifa; + lock->hook = radv_iface_add; + ifa->lock = lock; + + olock_acquire(lock); +} + +static void +radv_iface_remove(struct radv_iface *ifa) +{ + struct proto_radv *ra = ifa->ra; + RADV_TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name); + + rem_node(NODE ifa); + + rfree(ifa->sk); + rfree(ifa->timer); + rfree(ifa->lock); + + mb_free(ifa); +} + +static void +radv_if_notify(struct proto *p, unsigned flags, struct iface *iface) +{ + struct proto_radv *ra = (struct proto_radv *) p; + struct radv_config *cf = (struct radv_config *) (p->cf); + + if (iface->flags & IF_IGNORE) + return; + + if (flags & IF_CHANGE_UP) + { + struct radv_iface_config *ic = (struct radv_iface_config *) + iface_patt_find(&cf->patt_list, iface, NULL); + + if (ic) + radv_iface_new(ra, iface, ic); + + return; + } + + struct radv_iface *ifa = radv_iface_find(ra, iface); + if (!ifa) + return; + + if (flags & IF_CHANGE_DOWN) + { + radv_iface_remove(ifa); + return; + } + + if ((flags & IF_CHANGE_LINK) && (iface->flags & IF_LINK_UP)) + radv_iface_notify(ifa, RA_EV_INIT); +} + +static void +radv_ifa_notify(struct proto *p, unsigned flags, struct ifa *a) +{ + struct proto_radv *ra = (struct proto_radv *) p; + + if (a->flags & IA_SECONDARY) + return; + + if (a->scope <= SCOPE_LINK) + return; + + struct radv_iface *ifa = radv_iface_find(ra, a->iface); + + if (ifa) + radv_iface_notify(ifa, RA_EV_CHANGE); +} + +static struct proto * +radv_init(struct proto_config *c) +{ + struct proto *p = proto_new(c, sizeof(struct proto_radv)); + + p->if_notify = radv_if_notify; + p->ifa_notify = radv_ifa_notify; + return p; +} + +static int +radv_start(struct proto *p) +{ + struct proto_radv *ra = (struct proto_radv *) p; + // struct radv_config *cf = (struct radv_config *) (p->cf); + + init_list(&(ra->iface_list)); + + return PS_UP; +} + +static inline void +radv_iface_shutdown(struct radv_iface *ifa) +{ + if (ifa->sk) + radv_send_ra(ifa, 1); +} + +static int +radv_shutdown(struct proto *p) +{ + struct proto_radv *ra = (struct proto_radv *) p; + + struct radv_iface *ifa; + WALK_LIST(ifa, ra->iface_list) + radv_iface_shutdown(ifa); + + return PS_DOWN; +} + +static int +radv_reconfigure(struct proto *p, struct proto_config *c) +{ + struct proto_radv *ra = (struct proto_radv *) p; + // struct radv_config *old = (struct radv_config *) (p->cf); + struct radv_config *new = (struct radv_config *) c; + + /* + * The question is why there is a reconfigure function for RAdv if + * it has almost none internal state so restarting the protocol + * would probably suffice. One small reason is that restarting the + * protocol would lead to sending a RA with Router Lifetime 0 + * causing nodes to temporary remove their default routes. + */ + + struct iface *iface; + WALK_LIST(iface, iface_list) + { + struct radv_iface *ifa = radv_iface_find(ra, iface); + struct radv_iface_config *ic = (struct radv_iface_config *) + iface_patt_find(&new->patt_list, iface, NULL); + + if (ifa && ic) + { + ifa->cf = ic; + + /* We cheat here - always notify the change even if there isn't + any. That would leads just to a few unnecessary RAs. */ + radv_iface_notify(ifa, RA_EV_CHANGE); + } + + if (ifa && !ic) + { + radv_iface_shutdown(ifa); + radv_iface_remove(ifa); + } + + if (!ifa && ic) + radv_iface_new(ra, iface, ic); + } + + return 1; +} + + +struct protocol proto_radv = { + .name = "RAdv", + .template = "radv%d", + .init = radv_init, + .start = radv_start, + .shutdown = radv_shutdown, + .reconfigure = radv_reconfigure +}; -- cgit v1.2.3