diff options
Diffstat (limited to 'proto')
| -rw-r--r-- | proto/Doc | 1 | ||||
| -rw-r--r-- | proto/bfd/Doc | 1 | ||||
| -rw-r--r-- | proto/bfd/Makefile | 5 | ||||
| -rw-r--r-- | proto/bfd/bfd.c | 496 | ||||
| -rw-r--r-- | proto/bfd/bfd.h | 118 | ||||
| -rw-r--r-- | proto/bfd/config.Y | 113 | ||||
| -rw-r--r-- | proto/bfd/io.c | 587 | ||||
| -rw-r--r-- | proto/bfd/io.h | 62 | ||||
| -rw-r--r-- | proto/bfd/packets.c | 208 |
9 files changed, 1591 insertions, 0 deletions
@@ -1,4 +1,5 @@ H Protocols +C bfd C bgp C ospf C pipe diff --git a/proto/bfd/Doc b/proto/bfd/Doc new file mode 100644 index 00000000..7ee5d3ef --- /dev/null +++ b/proto/bfd/Doc @@ -0,0 +1 @@ +S bfd.c diff --git a/proto/bfd/Makefile b/proto/bfd/Makefile new file mode 100644 index 00000000..77b8bd2c --- /dev/null +++ b/proto/bfd/Makefile @@ -0,0 +1,5 @@ +source=bfd.c +root-rel=../../ +dir-name=proto/bfd + +include ../../Rules diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c new file mode 100644 index 00000000..4c7fe1f1 --- /dev/null +++ b/proto/bfd/bfd.c @@ -0,0 +1,496 @@ +#include "nest/bird.h" +#include "nest/iface.h" +#include "nest/protocol.h" +#include "nest/route.h" +#include "nest/cli.h" +#include "conf/conf.h" +#include "lib/socket.h" +#include "lib/resource.h" +#include "lib/string.h" + +#include "bfd.h" + + +#define HASH_ID_KEY loc_id +#define HASH_ID_NEXT next_id +#define HASH_ID_EQ(a,b) ((a)==(b)) +#define HASH_ID_FN(a) (a) + +#define HASH_IP_KEY addr +#define HASH_IP_NEXT next_ip +#define HASH_IP_EQ(a,b) ((a)==(b)) +#define HASH_IP_FN(a) (a == b) + +static u32 +bfd_get_free_id(struct bfd_proto *p) +{ + u32 id; + for (id = random_u32(); 1; id++) + if (id && !bfd_find_session_by_id(p, id)) + break; + + return id; +} + +static void +bfd_add_session(struct bfd_proto *p, ip_addr addr, struct bfd_session_config *opts) +{ + birdloop_enter(p->loop); + + struct bfd_session *s = sl_alloc(p->session_slab); + bzero(s, sizeof(struct bfd_session)); + + /* Initialization of state variables - see RFC 5880 3.8.1 */ + s->loc_state = BFD_STATE_DOWN; + s->rem_state = BFD_STATE_DOWN; + s->loc_id = bfd_get_free_id(p); + s->des_min_tx_int = s->des_min_tx_new = s->opts->idle_tx_int; + s->req_min_rx_int = s->req_min_rx_new = s->opts->min_rx_int; + s->detect_mult = s->opts->multiplier; + s->rem_min_rx_int = 1; + + HASH_INSERT(p->session_hash_id, HASH_ID, s); + HASH_INSERT(p->session_hash_ip, HASH_IP, s); + + s->tx_timer = tm2_new_set(xxx, bfd_rx_timer_hook, s, 0, 0); + s->hold_timer = tm2_new_set(xxx, bfd_hold_timer_hook, s, 0, 0); + bfd_session_update_tx_interval(s); + + birdloop_leave(p->loop); +} + +static void +bfd_open_session(struct bfd_proto *p, struct bfd_session *s, ip_addr local, struct iface *ifa) +{ + birdloop_enter(p->loop); + + s->bsock = bfd_get_socket(p, local, ifa); + s->local = local; + s->iface = ifa; + s->opened = 1; + + bfd_session_control_tx_timer(s); + + birdloop_leave(p->loop); +} + +static void +bfd_close_session(struct bfd_proto *p, struct bfd_session *s) +{ + birdloop_enter(p->loop); + + bfd_free_socket(s->bsock); + s->bsock = NULL; + s->local = IPA_NONE; + s->iface = NULL; + s->opened = 0; + + bfd_session_control_tx_timer(s); + + birdloop_leave(p->loop); +} + +static void +bfd_remove_session(struct bfd_proto *p, struct bfd_session *s) +{ + birdloop_enter(p->loop); + + bfd_free_socket(s->bsock); + + rfree(s->tx_timer); + rfree(s->hold_timer); + + HASH_REMOVE(p->session_hash_id, HASH_ID, s); + HASH_REMOVE(p->session_hash_ip, HASH_IP, s); + + sl_free(p->session_slab, s); + + birdloop_leave(p->loop); +} + +struct bfd_session * +bfd_find_session_by_id(struct bfd_proto *p, u32 id) +{ + return HASH_FIND(p->session_hash_id, HASH_ID, id); +} + +struct bfd_session * +bfd_find_session_by_addr(struct bfd_proto *p, ip_addr addr) +{ + return HASH_FIND(p->session_hash_ip, HASH_IP, addr); +} + +static void +bfd_rx_timer_hook(timer2 *t) +{ + struct bfd_session *s = timer->data; + + s->last_tx = xxx_now; + bfd_send_ctl(s->bfd, s, 0); +} + +static void +bfd_hold_timer_hook(timer2 *t) +{ + bfd_session_timeout(timer->data); +} + +static void +bfd_session_timeout(struct bfd_session *s) +{ + s->rem_state = BFD_STATE_DOWN; + s->rem_id = 0; + s->rem_min_tx_int = 0; + s->rem_min_rx_int = 1; + s->rem_demand_mode = 0; + + bfd_session_update_state(s, BFD_STATE_DOWN, BFD_DIAG_TIMEOUT); +} + +static void +bfd_session_control_tx_timer(struct bfd_session *s) +{ + if (!s->opened) + goto stop; + + if (s->passive && (s->rem_id == 0)) + goto stop; + + if (s->rem_demand_mode && + !s->poll_active && + (s->loc_state == BFD_STATE_UP) && + (s->rem_state == BFD_STATE_UP)) + goto stop; + + if (s->rem_min_rx_int == 0) + goto stop; + + /* So TX timer should run */ + if (tm2_active(s->tx_timer)) + return; + + tm2_start(s->tx_timer, 0); + return; + + stop: + tm2_stop(s->tx_timer); + s->last_tx = 0; +} + +static void +bfd_session_update_tx_interval(struct bfd_session *s) +{ + u32 tx_int = MAX(s->des_min_tx_int, s->rem_min_rx_int); + u32 tx_int_l = tx_int - (tx_int / 4); // 75 % + u32 tx_int_h = tx_int - (tx_int / 10); // 90 % + + s->tx_timer->recurrent = tx_int_l; + s->tx_timer->randomize = tx_int_h - tx_int_l; + + /* Do not set timer if no previous event */ + if (!s->last_tx) + return; + + /* Set timer relative to last tx_timer event */ + tm2_set(s->tx_timer, s->last_tx + tx_int_l); +} + +static void +bfd_session_update_detection_time(struct bfd_session *s, int kick) +{ + xxx_time timeout = (xxx_time) MAX(s->req_min_rx_int, s->rem_min_tx_int) * s->rem_detect_mult; + + if (kick) + s->last_rx = xxx_now; + + if (!s->last_rx) + return; + + tm2_set(s->hold_timer, s->last_rx + timeout); +} + +void +bfd_session_request_poll(struct bfd_session *s, u8 request) +{ + s->poll_scheduled |= request; + + if (s->poll_active) + return; + + s->poll_active = s->poll_scheduled; + s->poll_scheduled = 0; + bfd_send_ctl(s->bfd, s, 0); +} + +void +bfd_session_terminate_poll(struct bfd_session *s) +{ + u8 poll_done = s->poll_active & ~s->poll_scheduled; + + if (poll_done & BFD_POLL_TX) + s->des_min_tx_int = s->des_min_tx_new; + + if (poll_done & BFD_POLL_RX) + s->req_min_rx_int = s->req_min_rx_new; + + s->poll_active = 0; + + /* Timers are updated by caller - bfd_session_process_ctl() */ + + xxx_restart_poll(); +} + +void +bfd_session_process_ctl(struct bfd_session *s, u8 flags, u32 old_rx_int, u32 old_tx_int) +{ + if (s->poll_active && (flags & BFD_FLAG_FINAL)) + bfd_session_terminate_poll(s); + + if ((s->des_min_tx_int != old_rx_int) || (s->rem_min_rx_int != old_tx_int)) + bfd_session_update_tx_interval(s); + + bfd_session_update_detection_time(s, 1); + + /* Update session state */ + int next_state = 0; + int diag = BFD_DIAG_NOTHING; + + switch (s->loc_state) + { + case BFD_STATE_ADMIN_DOWN: + return; + + case BFD_STATE_DOWN: + if (s->rem_state == BFD_STATE_DOWN) next_state = BFD_STATE_INIT; + else if (s->rem_state == BFD_STATE_INIT) next_state = BFD_STATE_UP; + break; + + case BFD_STATE_INIT: + if (s->rem_state == BFD_STATE_ADMIN_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN; + else if (s->rem_state >= BFD_STATE_INIT) next_state = BFD_STATE_UP; + break; + + case BFD_STATE_UP: + if (s->rem_state <= BFD_STATE_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN; + break; + } + + if (next_state) + bfd_session_update_state(s, next_state, diag); + + bfd_session_control_tx_timer(s); + + if (flags & BFD_FLAG_POLL) + bfd_send_ctl(p, s, 1); +} + + +static void +bfd_session_set_min_tx(struct bfd_session *s, u32 val) +{ + /* Note that des_min_tx_int <= des_min_tx_new */ + + if (val == s->des_min_tx_new) + return; + + s->des_min_tx_new = val; + + /* Postpone timer update if des_min_tx_int increases and the session is up */ + if ((s->loc_state != BFD_STATE_UP) || (val < s->des_min_tx_int)) + { + s->des_min_tx_int = val; + bfd_session_update_tx_interval(s); + } + + bfd_session_request_poll(s, BFD_POLL_TX); +} + +static void +bfd_session_set_min_rx(struct bfd_session *s, u32 val) +{ + /* Note that req_min_rx_int >= req_min_rx_new */ + + if (val == s->req_min_rx_new) + return; + + s->req_min_rx_new = val; + + /* Postpone timer update if req_min_rx_int decreases and the session is up */ + if ((s->loc_state != BFD_STATE_UP) || (val > s->req_min_rx_int)) + { + s->req_min_rx_int = val; + bfd_session_update_detection_time(s, 0); + } + + bfd_session_request_poll(s, BFD_POLL_RX); +} + +static void +bfd_start_neighbor(struct bfd_proto *p, struct bfd_neighbor *n) +{ + n->session = bfd_add_session(p, n->addr, n->opts); + + if (n->opts->multihop) + { + bfd_open_session(p, n->session, n->local, NULL); + return; + } + + struct neighbor *nb = neigh_find2(&p->p, &n->addr, n->iface, NEF_STICKY); + if (!nb) + { + log(L_ERR "%s: Invalid remote address %I%J", p->p.name, n->addr, n->iface); + return; + } + + if (nb->data) + { + log(L_ERR "%s: Duplicate remote address %I", p->p.name, n->addr); + return; + } + + nb->data = n->session; + + if (nb->scope > 0) + bfd_open_session(p, n->session, nb->iface->addr->ip, nb->iface); + else + TRACE(D_EVENTS, "Waiting for %I%J to become my neighbor", n->addr, cf->iface); +} + +static void +bfd_stop_neighbor(struct bfd_proto *p, struct bfd_neighbor *n) +{ + if (!n->opts->multihop) + { + struct neighbor *nb = neigh_find2(&p->p, &n->addr, n->iface, 0); + if (nb) + nb->data = NULL; + } + + bfd_remove_session(p, n->session); +} + + +static void +bfd_neigh_notify(struct neighbor *nb) +{ + struct bfd_proto *p = (struct bfd_proto *) nb->proto; + struct bfd_session *s = nb->data; + + if (!s) + return; + + if ((nb->scope > 0) && !s->opened) + bfd_open_session(p, s, nb->iface->addr->ip, nb->iface); + + if ((nb->scope <= 0) && s->opened) + bfd_close_session(p, s); +} + + + +static struct proto * +bfd_init(struct proto_config *c) +{ + struct proto *p = proto_new(c, sizeof(struct bfd_proto)); + + p->if_notify = bfd_if_notify; + p->ifa_notify = bfd_ifa_notify; + + return p; +} + +static int +bfd_start(struct proto *P) +{ + struct bfd_proto *p = (struct bfd_proto *) P; + struct bfd_config *cf = (struct bfd_config *) (P->cf); + + p->session_slab = sl_new(P->pool, sizeof(struct bfd_session)); + init_list(&p->sockets); + + HASH_INIT(p->session_hash_id, P->pool, 16); + HASH_INIT(p->session_hash_ip, P->pool, 16); + + struct bfd_neighbor *n; + WALK_LIST(n, cf->neighbors) + bfd_start_neighbor(p, n); + + return PS_UP; +} + + +static int +bfd_shutdown(struct proto *P) +{ + struct bfd_proto *p = (struct bfd_proto *) P; + + return PS_DOWN; +} + +static inline int +bfd_same_neighbor(struct bfd_neighbor *x, struct bfd_neighbor *y) +{ + return ipa_equal(x->addr, y->addr) && ipa_equal(x->local, y->local) && + (x->iface == y->iface) && (x->opts->multihop == y->opts->multihop); +} + +static void +bfd_match_neighbor(struct bfd_proto *p, struct bfd_neighbor *on, struct bfd_config *new) +{ + struct bfd_neighbor *nn; + + if (r->neigh) + r->neigh->data = NULL; + + WALK_LIST(nn, new->neighbors) + if (bfd_same_neighbor(nn, on)) + { + nn->session = on->session; + // XXX reconfiguration of session? + return; + } + + bfd_stop_neighbor(p, on); +} + +static int +bfd_reconfigure(struct proto *P, struct proto_config *c) +{ + struct bfd_proto *p = (struct bfd_proto *) P; + struct bfd_config *old = (struct bfd_config *) (P->cf); + struct bfd_config *new = (struct bfd_config *) c; + struct bfd_neighbor *n; + + WALK_LIST(n, old->neighbors) + bfd_match_neighbor(p, n, new); + + WALK_LIST(n, new->neighbors) + if (!n->session) + bfd_start_neighbor(p, n); + + return 1; +} + +static void +bfd_copy_config(struct proto_config *dest, struct proto_config *src) +{ + struct bfd_config *d = (struct bfd_config *) dest; + struct bfd_config *s = (struct bfd_config *) src; + + /* We clean up patt_list, ifaces are non-sharable */ + init_list(&d->patt_list); + + /* We copy pref_list, shallow copy suffices */ + cfg_copy_list(&d->pref_list, &s->pref_list, sizeof(struct bfd_prefix_config)); +} + +struct protocol proto_bfd = { + .name = "BFD", + .template = "bfd%d", + .init = bfd_init, + .start = bfd_start, + .shutdown = bfd_shutdown, + .reconfigure = bfd_reconfigure, + .copy_config = bfd_copy_config, +}; diff --git a/proto/bfd/bfd.h b/proto/bfd/bfd.h new file mode 100644 index 00000000..a54053d3 --- /dev/null +++ b/proto/bfd/bfd.h @@ -0,0 +1,118 @@ + +#ifndef _BIRD_BFD_H_ +#define _BIRD_BFD_H_ + +#define BFD_CONTROL_PORT 3784 +#define BFD_ECHO_PORT 3785 +#define BFD_MULTI_CTL_PORT 4784 + +#define BFD_DEFAULT_MIN_RX_INT (10 MS) +#define BFD_DEFAULT_MIN_TX_INT (100 MS) +#define BFD_DEFAULT_IDLE_TX_INT (1 S) +#define BFD_DEFAULT_MULTIPLIER 5 + + +struct bfd_config +{ + struct proto_config c; + list neighbors; /* List of struct bfd_neighbor */ +}; + +struct bfd_session_config +{ + u32 min_rx_int; + u32 min_tx_int; + u32 idle_tx_int; + u8 multiplier; + u8 multihop; + u8 passive; +}; + +struct bfd_neighbor +{ + node n; + ip_addr addr; + ip_addr local; + struct iface *iface; + struct bfd_session_config *opts; + + struct bfd_session *session; +}; + +struct bfd_proto +{ + struct proto p; + + slab *session_slab; + HASH(struct bfd_session) session_hash_id; + HASH(struct bfd_session) session_hash_ip; + + list sockets; +}; + +struct bfd_socket +{ + node n; + sock *sk; + u32 uc; +}; + +struct bfd_session +{ + node n; + struct bfd_session *next_id; /* Next in bfd.session_hash_id */ + struct bfd_session *next_ip; /* Next in bfd.session_hash_ip */ + + u8 opened; + u8 poll_active; + u8 poll_scheduled; + + u8 loc_state; + u8 rem_state; + u8 loc_diag; + u32 loc_id; /* Local session ID (local discriminator) */ + u32 rem_id; /* Remote session ID (remote discriminator) */ + u32 des_min_tx_int; /* Desired min rx interval, local option */ + u32 des_min_tx_new; /* Used for des_min_tx_int change */ + u32 req_min_rx_int; /* Required min tx interval, local option */ + u32 req_min_rx_new; /* Used for req_min_rx_int change */ + u32 rem_min_tx_int; /* Last received des_min_tx_int */ + u32 rem_min_rx_int; /* Last received req_min_rx_int */ + u8 demand_mode; /* Currently unused */ + u8 rem_demand_mode; + u8 detect_mult; /* Announced detect_mult, local option */ + u8 rem_detect_mult; /* Last received detect_mult */ + + xxx_time last_tx; /* Time of last sent periodic control packet */ + xxx_time last_rx; /* Time of last received valid control packet */ + + timer2 *tx_timer; /* Periodic control packet timer */ + timer2 *hold_timer; /* Timer for session down detection time */ +}; + + + +#define BFD_STATE_ADMIN_DOWN 0 +#define BFD_STATE_DOWN 1 +#define BFD_STATE_INIT 2 +#define BFD_STATE_UP 3 + +#define BFD_DIAG_NOTHING 0 +#define BFD_DIAG_TIMEOUT 1 +#define BFD_DIAG_ECHO_FAILED 2 +#define BFD_DIAG_NEIGHBOR_DOWN 3 +#define BFD_DIAG_FWD_RESET 4 +#define BFD_DIAG_PATH_DOWN 5 +#define BFD_DIAG_C_PATH_DOWN 6 +#define BFD_DIAG_ADMIN_DOWN 7 +#define BFD_DIAG_RC_PATH_DOWN 8 + +#define BFD_POLL_TX 1 +#define BFD_POLL_RX 2 + + + + + + +#endif _BIRD_BFD_H_ diff --git a/proto/bfd/config.Y b/proto/bfd/config.Y new file mode 100644 index 00000000..a5414d4e --- /dev/null +++ b/proto/bfd/config.Y @@ -0,0 +1,113 @@ +/* + * BIRD -- Router Advertisement Configuration + * + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +CF_HDR + +#include "proto/bfd/bfd.h" + +CF_DEFINES + +#define BFD_CFG ((struct bfd_config *) this_proto) +#define BFD_SESSION this_bfd_session +#define BFD_NEIGHBOR this_bfd_neighbor + +static struct bfd_session_config *this_bfd_session; +static struct bfd_neighbor *this_bfd_neighbor; + + +CF_DECLS + +CF_KEYWORDS(BFD, MIN, IDLE, RX, TX, INTERVAL, MULTIPLIER, MULTIHOP, PASSIVE, + NEIGHBOR) + +%type <iface> bfd_neigh_iface +%type <a> bfd_neigh_local + +CF_GRAMMAR + +CF_ADDTO(proto, bfd_proto) + +bfd_proto_start: proto_start BFD +{ + this_proto = proto_config_new(&proto_bfd, sizeof(struct bfd_config), $1); + init_list(&BFD_CFG->neighbors); +}; + +bfd_proto_item: + proto_item + | bfd_neighbor + ; + +bfd_proto_opts: + /* empty */ + | bfd_proto_opts bfd_proto_item ';' + ; + +bfd_proto: + bfd_proto_start proto_name '{' bfd_proto_opts '}'; + + +bfd_session_start: +{ + this_bfd_session = cfg_allocz(sizeof(struct bfd_session_config)); + + BFD_SESSION->min_rx_int = BFD_DEFAULT_MIN_RX_INT; + BFD_SESSION->min_tx_int = BFD_DEFAULT_MIN_TX_INT; + BFD_SESSION->idle_tx_int = BFD_DEFAULT_IDLE_TX_INT; + BFD_SESSION->multiplier = BFD_DEFAULT_MULTIPLIER; +}; + +bfd_session_item: + INTERVAL expr_us { BFD_SESSION->min_rx_int = BFD_SESSION->min_tx_int = $2; } + | MIN RX INTERVAL expr_us { BFD_SESSION->min_rx_int = $4; } + | MIN TX INTERVAL expr_us { BFD_SESSION->min_tx_int = $4; } + | IDLE TX INTERVAL expr_us { BFD_SESSION->idle_tx_int = $4; } + | MULTIPLIER expr { BFD_SESSION->multiplier = $2; } + | MULTIHOP bool { BFD_SESSION->multihop = $2; } + | PASSIVE bool { BFD_SESSION->passive = $2; } + ; + +bfd_session_opts: + /* empty */ + | bfd_session_opts bfd_session_item ';' + ; + +bfd_session_opt_list: + /* empty */ + | '{' bfd_session_opts '}' + ; + +bfd_session: + bfd_session_start bfd_session_opt_list; + + +bfd_neigh_iface: + /* empty */ { $$ = NULL; } + | '%' SYM { $$ = if_get_by_name($2->name); } + | DEV TEXT { $$ = if_get_by_name($2); } + ; + +bfd_neigh_local: + /* empty */ { $$ = IPA_NONE; } + | LOCAL ipa { $$ = $2; } + ; + +bfd_neighbor: NEIGHBOR ipa bfd_neigh_iface bfd_neigh_local bfd_session +{ + this_bfd_neighbor = cfg_allocz(sizeof(struct bfd_neighbor)); + add_tail(&BFD_CFG->neighbors, NODE this_bfd_neighbor); + + BFD_NEIGHBOR->addr = $2; + BFD_NEIGHBOR->local = $4; + BFD_NEIGHBOR->iface = $3; + BFD_NEIGHBOR->opts = BFD_SESSION; +}; + + +CF_CODE + +CF_END diff --git a/proto/bfd/io.c b/proto/bfd/io.c new file mode 100644 index 00000000..f7fbc67a --- /dev/null +++ b/proto/bfd/io.c @@ -0,0 +1,587 @@ + +#include "lib/buffer.h" +#include "lib/heap.h" + +struct birdloop +{ + pool *pool; + + int wakeup_fds[2]; + u8 poll_active; + + xxx_time last_time; + xxx_time real_time; + u8 use_monotonic_clock; + + BUFFER(timer2 *) timers; + list event_list; + list sock_list; + uint sock_num; + + BUFFER(sock *) poll_sk; + BUFFER(struct pollfd) poll_fd; + u8 poll_changed; + u8 close_scheduled; + +}; + + +static void times_update_alt(struct birdloop *loop); + +static int +times_init(struct birdloop *loop) +{ + struct timespec ts; + int rv; + + rv = clock_gettime(CLOCK_MONOTONIC, &ts); + if (rv < 0) + { + // log(L_WARN "Monotonic clock is missing"); + + loop->use_monotonic_clock = 0; + loop->last_time = 0; + loop->real_time = 0; + times_update_alt(loop); + return; + } + + /* + if ((tv.tv_sec < 0) || (((s64) tv.tv_sec) > ((s64) 1 << 40))) + log(L_WARN "Monotonic clock is crazy"); + */ + + loop->use_monotonic_clock = 1; + loop->last_time = (tv.tv_sec S) + (tv.tv_nsec / 1000); + loop->real_time = 0; +} + +static void +times_update_pri(struct birdloop *loop) +{ + struct timespec ts; + int rv; + + rv = clock_gettime(CLOCK_MONOTONIC, &ts); + if (rv < 0) + die("clock_gettime: %m"); + + xxx_time new_time = (tv.tv_sec S) + (tv.tv_nsec / 1000); + + /* + if (new_time < loop->last_time) + log(L_ERR "Monotonic clock is broken"); + */ + + loop->last_time = new_time; + loop->real_time = 0; +} + +static void +times_update_alt(struct birdloop *loop) +{ + struct timeval tv; + int rv; + + rv = gettimeofday(&tv, NULL); + if (rv < 0) + die("gettimeofday: %m"); + + xxx_time new_time = (tv.tv_sec S) + tv.tv_usec; + xxx_time delta = new_time - loop->real_time; + + if ((delta < 0) || (delta > (60 S))) + { + /* + if (loop->real_time) + log(L_WARN "Time jump, delta %d us", (int) delta); + */ + + delta = 100 MS; + } + + loop->last_time += delta; + loop->real_time = new_time; +} + +static void +times_update(struct birdloop *loop) +{ + if (loop->use_monotonic_clock) + times_update_pri(loop); + else + times_update_alt(loop); +} + + + +static void +pipe_new(int *pfds) +{ + int pfds[2], rv; + sock *sk; + + rv = pipe(pfds); + if (rv < 0) + die("pipe: %m"); + + if (fcntl(pfds[0], F_SETFL, O_NONBLOCK) < 0) + die("fcntl(O_NONBLOCK): %m"); + + if (fcntl(pfds[1], F_SETFL, O_NONBLOCK) < 0) + die("fcntl(O_NONBLOCK): %m"); +} + +static void +wakeup_init(struct birdloop *loop) +{ + pipe_new(loop->wakeup_fds); +} + +static void +wakeup_drain(struct birdloop *loop) +{ + char buf[64]; + int rv; + + try: + rv = read(loop->wakeup_fds[0], buf, 64); + if (rv < 0) + { + if (errno == EINTR) + goto try; + if (errno == EAGAIN) + return; + die("wakeup read: %m"); + } + if (rv == 64) + goto try; +} + +static void +wakeup_kick(struct birdloop *loop) +{ + u64 v = 1; + int rv; + + try: + rv = write(loop->wakeup_fds[1], &v, sizeof(u64)); + if (rv < 0) + { + if (errno == EINTR) + goto try; + if (errno == EAGAIN) + return; + die("wakeup write: %m"); + } +} + + + + +static inline uint events_waiting(struct birdloop *loop) +{ return !EMPTY_LIST(loop->event_list); } + +static void +events_init(struct birdloop *loop) +{ + list_init(&poll->event_list); +} + +static void +events_fire(struct birdloop *loop) +{ + times_update(loop); + ev_run_list(&loop->event_list); +} + +void +ev2_schedule(event *e) +{ + if (loop->poll_active && EMPTY_LIST(loop->event_list)) + wakeup_kick(loop); + + if (e->n.next) + rem_node(&e->n); + + add_tail(&loop->event_list, &e->n); +} + + +#define TIMER_LESS(a,b) ((a)->expires < (b)->expires) +#define TIMER_SWAP(heap,a,b,t) (t = heap[a], heap[a] = heap[b], heap[b] = t, \ + heap[a]->index = (a), heap[b]->index = (b)) + + +static inline uint timers_count(struct birdloop *loop) +{ return loop->timers.used - 1; } + +static inline timer2 *timers_first(struct birdloop *loop) +{ return (loop->timers.used > 1) ? loop->timers.data[1] : NULL; } + + +static void +tm2_free(resource *r) +{ + timer2 *t = (timer2 *) r; + + tm2_stop(t); +} + +static void +tm2_dump(resource *r) +{ + timer2 *t = (timer2 *) r; + + debug("(code %p, data %p, ", t->hook, t->data); + if (t->randomize) + debug("rand %d, ", t->randomize); + if (t->recurrent) + debug("recur %d, ", t->recurrent); + if (t->expires) + debug("expires in %d sec)\n", t->expires - xxx_now); + else + debug("inactive)\n"); +} + +static struct resclass tm2_class = { + "Timer", + sizeof(timer), + tm2_free, + tm2_dump, + NULL, + NULL +}; + +timer2 * +tm2_new(pool *p) +{ + timer2 *t = ralloc(p, &tm2_class); + t->index = -1; + return t; +} + +void +tm2_start(timer2 *t, xxx_time after) +{ + xxx_time when = loop->last_time + after; + uint tc = timers_count(loop); + + if (!t->expires) + { + t->index = ++tc; + t->expires = when; + BUFFER_PUSH(loop->timers) = t; + HEAP_INSERT(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP); + } + else if (t->expires < when) + { + t->expires = when; + HEAP_INCREASE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index); + } + else if (t->expires > when) + { + t->expires = when; + HEAP_DECREASE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index); + } + + if (loop->poll_active && (t->index == 1)) + wakeup_kick(loop); +} + +void +tm2_stop(timer2 *t) +{ + if (!t->expires) + return; + + uint tc = timers_count(XXX); + HEAP_DELETE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index); + BUFFER_POP(loop->timers); + + t->index = -1; + t->expires = 0; +} + +static void +timers_init(struct birdloop *loop) +{ + BUFFER_INIT(loop->timers, loop->pool, 4); + BUFFER_PUSH(loop->timers) = NULL; +} + +static void +timers_fire(struct birdloop *loop) +{ + xxx_time base_time; + timer2 *t; + + times_update(loop); + base_time = loop->last_time; + + while (t = timers_first(loop)) + { + if (t->expires > base_time) + return; + + if (t->recurrent) + { + xxx_time after = t->recurrent; + xxx_time delta = loop->last_time - t->expires; + + if (t->randomize) + after += random() % (t->randomize + 1); + + if (delta > after) + delta = 0; + + tm2_start(t, after - delta); + } + else + tm2_stop(t); + + t->hook(t); + } +} + + +static void +sockets_init(struct birdloop *loop) +{ + list_init(&poll->sock_list); + poll->sock_num = 0; + + BUFFER_INIT(loop->poll_sk, loop->pool, 4); + BUFFER_INIT(loop->poll_fd, loop->pool, 4); + poll_changed = 0; +} + +static void +sockets_add(struct birdloop *loop, sock *s) +{ + add_tail(&loop->sock_list, &s->n); + loop->sock_num++; + + s->index = -1; + loop->poll_changed = 1; + + if (loop->poll_active) + wakeup_kick(loop); +} + +void +sk_start(sock *s) +{ + sockets_add(xxx_loop, s); +} + +static void +sockets_remove(struct birdloop *loop, sock *s) +{ + rem_node(&s->n); + loop->sock_num--; + + if (s->index >= 0) + s->poll_sk.data[sk->index] = NULL; + + s->index = -1; + loop->poll_changed = 1; + + /* Wakeup moved to sk_stop() */ +} + +void +sk_stop(sock *s) +{ + sockets_remove(xxx_loop, s); + + if (loop->poll_active) + { + loop->close_scheduled = 1; + wakeup_kick(loop); + } + else + close(s->fd); + + s->fd = -1; +} + +static inline uint sk_want_events(sock *s) +{ return (s->rx_hook ? POLLIN : 0) | ((s->ttx != s->tpos) ? POLLOUT : 0); } + +static void +sockets_update(struct birdloop *loop, sock *s) +{ + if (s->index >= 0) + s->poll_fd.data[s->index].events = sk_want_events(s); +} + +static void +sockets_prepare(struct birdloop *loop) +{ + BUFFER_SET(loop->poll_sk, loop->sock_num + 1); + BUFFER_SET(loop->poll_fd, loop->sock_num + 1); + + struct pollfd *pfd = loop->poll_fd.data; + sock **psk = loop->poll_sk.data; + int i = 0; + node *n; + + WALK_LIST(n, &loop->sock_list) + { + sock *s = SKIP_BACK(sock, n, n); + + ASSERT(i < loop->sock_num); + + s->index = i; + *psk = s; + pfd->fd = s->fd; + pfd->events = sk_want_events(s); + pfd->revents = 0; + + pfd++; + psk++; + i++; + } + + ASSERT(i == loop->sock_num); + + /* Add internal wakeup fd */ + *psk = NULL; + pfd->fd = loop->wakeup_fds[0]; + pfd->events = POLLIN; + pfd->revents = 0; + + loop->poll_changed = 0; +} + +static void +sockets_close_fds(struct birdloop *loop) +{ + struct pollfd *pfd = loop->poll_fd.data; + sock **psk = loop->poll_sk.data; + int poll_num = loop->poll_fd.used - 1; + + int i; + for (i = 0; i < poll_num; i++) + if (psk[i] == NULL) + close(pfd[i].fd); + + loop->close_scheduled = 0; +} + + +static void +sockets_fire(struct birdloop *loop) +{ + struct pollfd *pfd = loop->poll_fd.data; + sock **psk = loop->poll_sk.data; + int poll_num = loop->poll_fd.used - 1; + + times_update(loop); + + /* Last fd is internal wakeup fd */ + if (pfd[loop->sock_num].revents & POLLIN) + wakeup_drain(loop); + + int i; + for (i = 0; i < poll_num; pfd++, psk++, i++) + { + int e = 1; + + if (! pfd->revents) + continue; + + if (pfd->revents & POLLNVAL) + die("poll: invalid fd %d", pfd->fd); + + if (pfd->revents & POLLIN) + while (e && *psk && (*psk)->rx_hook) + e = sk_read(*psk); + + e = 1; + if (pfd->revents & POLLOUT) + while (e && *psk) + e = sk_write(*psk); + } +} + + +struct birdloop * +birdloop_new(pool *p) +{ + struct birdloop *loop = mb_allocz(p, sizeof(struct birdloop)); + p->pool = p; + + times_init(loop); + wakeup_init(loop); + + events_init(loop); + timers_init(loop); + sockets_init(loop); + + return loop; +} + +void +birdloop_enter(struct birdloop *loop) +{ + pthread_mutex_lock(loop->mutex); +} + +void +birdloop_leave(struct birdloop *loop) +{ + pthread_mutex_unlock(loop->mutex); +} + + +void +birdloop_main(struct birdloop *loop) +{ + timer2 *t; + int timeout; + + while (1) + { + events_fire(loop); + timers_fire(loop); + + times_update(loop); + if (events_waiting(loop)) + timeout = 0; + else if (t = timers_first(loop)) + timeout = (tm2_remains(t) TO_MS) + 1; + else + timeout = -1; + + if (loop->poll_changed) + sockets_prepare(loop); + + loop->poll_active = 1; + pthread_mutex_unlock(loop->mutex); + + try: + rv = poll(loop->poll_fd.data, loop->poll_fd.used, timeout); + if (rv < 0) + { + if (errno == EINTR || errno == EAGAIN) + goto try; + die("poll: %m"); + } + + pthread_mutex_lock(loop->mutex); + loop->poll_active = 0; + + if (loop->close_scheduled) + sockets_close_fds(loop); + + if (rv) + sockets_fire(loop); + + timers_fire(loop); + } +} + + + diff --git a/proto/bfd/io.h b/proto/bfd/io.h new file mode 100644 index 00000000..7fc45194 --- /dev/null +++ b/proto/bfd/io.h @@ -0,0 +1,62 @@ + +typedef s64 xxx_time; + +typedef struct timer +{ + resource r; + void (*hook)(struct timer2 *); + void *data; + + xxx_time expires; /* 0=inactive */ + unsigned randomize; /* Amount of randomization */ + unsigned recurrent; /* Timer recurrence */ + + int index; +} timer; + + + +void ev2_schedule(event *e); + + + +timer2 *tm2_new(pool *p); +void tm2_start(timer2 *t, xxx_time after); +void tm2_stop(timer2 *t); + +static inline xxx_time +tm2_remains(timer2 *t) +{ + return (t->expires > xxxnow) ? t->expires - xxxnow : 0; +} + +static inline void +tm2_start_max(timer2 *t, xxx_time after) +{ + xxx_time rem = tm2_remains(t); + tm2_start(t, MAX(rem, after)); +} + +static inline timer2 * +tm2_new_set(pool *p, void (*hook)(struct timer2 *), void *data, uint rec, uint rand) +{ + timer2 *t = tm2_new(p); + t->hook = hook; + t->data = data; + t->recurrent = rec; + t->randomize = rand; + return t; +} + + + +void sk_start(sock *s); +void sk_stop(sock *s); + + + +struct birdloop *birdloop_new(pool *p); +void birdloop_enter(struct birdloop *loop); +void birdloop_leave(struct birdloop *loop); +void birdloop_main(struct birdloop *loop); + diff --git a/proto/bfd/packets.c b/proto/bfd/packets.c new file mode 100644 index 00000000..e48a5aaa --- /dev/null +++ b/proto/bfd/packets.c @@ -0,0 +1,208 @@ + + +#define BFD_FLAG_POLL (1 << 5) +#define BFD_FLAG_FINAL (1 << 4) +#define BFD_FLAG_CPI (1 << 3) +#define BFD_FLAG_AP (1 << 2) +#define BFD_FLAG_DEMAND (1 << 1) +#define BFD_FLAG_MULTIPOINT (1 << 0) + + +struct bfd_ctl_packet +{ + u8 vdiag; /* version and diagnostic */ + u8 flags; /* state and flags */ + u8 detect_mult; + u8 length; + u32 snd_id; /* sender ID, aka 'my discriminator' */ + u32 rcv_id; /* receiver ID, aka 'your discriminator' */ + u32 des_min_tx_int; + u32 req_min_rx_int; + u32 req_min_echo_rx_int; +}; + + +static inline void bfd_pack_vdiag(u8 version, u8 diag) +{ return (version << 5) | diag; } + +static inline void bfd_pack_flags(u8 state, u8 flags) +{ return (state << 6) | diag; } + +static inline u8 bfd_pkt_get_version(struct bfd_ctl_packet *pkt) +{ return pkt->vdiag >> 5; } + +static inline u8 bfd_pkt_get_diag(struct bfd_ctl_packet *pkt) +{ return pkt->vdiag && 0x1f; } + + +static inline u8 bfd_pkt_get_state(struct bfd_ctl_packet *pkt) +{ return pkt->flags >> 6; } + +static inline void bfd_pkt_set_state(struct bfd_ctl_packet *pkt, u8 val) +{ pkt->flags = val << 6; } + + +void +bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final) +{ + sock *sk = p->skX; + struct bfd_ctl_packet *pkt = (struct ospf_packet *) sk->tbuf; + + pkt->vdiag = bfd_pack_vdiag(1, s->loc_diag); + pkt->flags = bfd_pack_flags(s->loc_state, 0); + pkt->detect_mult = s->detect_mult; + pkt->length = 24; + pkt->snd_id = htonl(s->loc_id); + pkt->rcv_id = htonl(s->rem_id); + pkt->des_min_tx_int = htonl(s->des_min_tx_int); + pkt->req_min_rx_int = htonl(s->req_min_rx_int); + pkt->req_min_echo_rx_int = 0; + + if (final) + pkt->flags |= BFD_FLAG_FINAL; + else if (s->poll_active) + pkt->flags |= BFD_FLAG_POLL; + + // XXX + sk_send_to(sk, len, dst, 0); +} + +int +bfd_ctl_rx_hook(sock *sk, int len) +{ + struct bfd_proto *p = sk->data; + struct bfd_ctl_packet *pkt =sk->rbuf; + + if (len < BFD_BASE_LEN) + DROP("too short", len); + + u8 version = bfd_pkt_get_version(pkt); + if (version != 1) + DROP("version mismatch", version); + + if ((pkt->length < BFD_BASE_LEN) || (pkt->length > len)) + DROP("length mismatch", pkt->length); + + if (pkt->detect_mult == 0) + DROP("invalid detect mult", 0); + + if (pkt->flags & BFD_FLAG_MULTIPOINT) + DROP("invalid flags", pkt->flags); + + if (pkt->snd_id == 0) + DROP("invalid my discriminator", 0); + + struct bfd_session *s; + u32 id = ntohl(pkt->rcv_id); + + if (id) + { + s = bfd_find_session_by_id(p, id); + + if (!s) + DROP("unknown session", id); + } + else + { + u8 ps = bfd_pkt_get_state(pkt); + if (ps > BFD_STATE_DOWN) + DROP("invalid init state", ps); + + s = bfd_find_session_by_ip(p, sk->faddr); + + /* FIXME: better session matching and message */ + if (!s || !s->opened) + return; + } + + /* FIXME: better authentication handling and message */ + if (pkt->flags & BFD_FLAG_AP) + DROP("authentication not supported", 0); + + + u32 old_rx_int = s->des_min_tx_int; + u32 old_tx_int = s->rem_min_rx_int; + + s->rem_id = ntohl(pkt->snd_id); + s->rem_state = bfd_pkt_get_state(pkt); + s->rem_demand_mode = pkt->flags & BFD_FLAG_DEMAND; + s->rem_min_tx_int = ntohl(pkt->des_min_tx_int); + s->rem_min_rx_int = ntohl(pkt->req_min_rx_int); + s->rem_detect_mult = pkt->detect_mult; + + bfd_session_process_ctl(s, pkt->flags, xxx); + return 1; + + drop: + // log(L_WARN "%s: Bad packet from %I - %s (%u)", p->p.name, sk->faddr, err_dsc, err_val); + return 1; +} + +sock * +bfd_open_rx_sk(struct bfd_proto *p, int multihop) +{ + sock *sk = sk_new(p->p.pool); + sk->type = SK_UDP; + sk->sport = !multihop ? BFD_CONTROL_PORT : BFD_MULTI_CTL_PORT; + sk->data = p; + + sk->rbsize = 64; // XXX + sk->rx_hook = bfd_rx_hook; + sk->err_hook = bfd_err_hook; + + sk->flags = SKF_LADDR_RX | (!multihop ? SKF_TTL_RX : 0); + + if (sk_open(sk) < 0) + goto err; +} + +static inline sock * +bfd_open_tx_sk(struct bfd_proto *p, ip_addr local, struct iface *ifa) +{ + sock *sk = sk_new(p->p.pool); + sk->type = SK_UDP; + sk->saddr = local; + sk->data = p; + + sk->tbsize = 64; // XXX + sk->err_hook = bfd_err_hook; + + sk->iface = new; + + sk->tos = PATT->tx_tos; + sk->priority = PATT->tx_priority; + sk->ttl = PATT->ttl_security ? 255 : 1; + + if (sk_open(sk) < 0) + goto err; + +} + +struct bfd_socket * +bfd_get_socket(struct bfd_proto *p, ip_addr local, struct iface *ifa) +{ + struct bfd_socket *sk; + + WALK_LIST(sk, p->sockets) + if (ipa_equal(sk->sk->saddr, local) && (sk->sk->iface == ifa)) + return sk->uc++, sk; + + sk = mb_allocz(p->p.pool, sizeof(struct bfd_socket)); + sk->sk = bfd_open_tx_sk(p, local, ifa); + sk->uc = 1; + add_tail(&p->sockets, &sk->n); + + return sk; +} + +void +bfd_free_socket(struct bfd_socket *sk) +{ + if (!sk || --sk->uc) + return; + + rem_node(&sk->n); + sk_stop(sk->sk); + rfree(sk->sk); + mb_free(sk); +} |