Jerry/bird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
bird/proto/babel/packets.c
Toke Høiland-Jørgensen ac724bde4c
babel: Add support for the RTT extension 
This adds support to the Babel protocol for the RTT extension specified in
draft-ietf-babel-rtt-extension. While this extension is not yet at the RFC
stage, it is one of the more useful extensions to Babel[0], so it seems
worth having in Bird as well.

The extension adds timestamps to Hello and IHU TLVs and uses these to
compute an RTT to each neighbour. An extra per-neighbour cost is then
computed from the RTT based on a minimum and maximum interval and cost
value specified in the configuration. The primary use case for this is
improving routing in a geographically distributed tunnel-based overlay
network.

The implementation follows the babeld implementation when picking constants
and default configuration values. It also uses the same RTT smoothing
algorithm as babeld, and follows it in adding a new 'tunnel' interface type
which enables RTT by default.

[0] https://alioth-lists.debian.net/pipermail/babel-users/2022-April/003932.html

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
2022-12-07 00:12:14 +08:00

2157 lines
55 KiB
C
Raw Blame History

/*
* BIRD -- The Babel protocol
*
* Copyright (c) 2015--2016 Toke Hoiland-Jorgensen
* (c) 2016--2017 Ondrej Zajicek <santiago@crfreenet.org>
* (c) 2016--2017 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
* This file contains the packet and TLV handling code for the protocol.
*/
#include "babel.h"
#include "lib/mac.h"
struct babel_pkt_header {
u8 magic;
u8 version;
u16 length;
} PACKED;
struct babel_tlv {
u8 type;
u8 length;
u8 value[0];
} PACKED;
struct babel_tlv_ack_req {
u8 type;
u8 length;
u16 reserved;
u16 nonce;
u16 interval;
} PACKED;
struct babel_tlv_ack {
u8 type;
u8 length;
u16 nonce;
} PACKED;
struct babel_tlv_hello {
u8 type;
u8 length;
u16 flags;
u16 seqno;
u16 interval;
} PACKED;
struct babel_tlv_ihu {
u8 type;
u8 length;
u8 ae;
u8 reserved;
u16 rxcost;
u16 interval;
u8 addr[0];
} PACKED;
struct babel_subtlv_timestamp {
u8 type;
u8 length;
u32 tstamp;
u32 tstamp_rcvd; /* only used in IHU */
} PACKED;
struct babel_tlv_router_id {
u8 type;
u8 length;
u16 reserved;
u64 router_id;
} PACKED;
struct babel_tlv_next_hop {
u8 type;
u8 length;
u8 ae;
u8 reserved;
u8 addr[0];
} PACKED;
struct babel_tlv_update {
u8 type;
u8 length;
u8 ae;
u8 flags;
u8 plen;
u8 omitted;
u16 interval;
u16 seqno;
u16 metric;
u8 addr[0];
} PACKED;
struct babel_tlv_route_request {
u8 type;
u8 length;
u8 ae;
u8 plen;
u8 addr[0];
} PACKED;
struct babel_tlv_seqno_request {
u8 type;
u8 length;
u8 ae;
u8 plen;
u16 seqno;
u8 hop_count;
u8 reserved;
u64 router_id;
u8 addr[0];
} PACKED;
struct babel_subtlv_source_prefix {
u8 type;
u8 length;
u8 plen;
u8 addr[0];
} PACKED;
struct babel_tlv_mac {
u8 type;
u8 length;
u8 mac[0];
} PACKED;
struct babel_tlv_pc {
u8 type;
u8 length;
u32 pc;
u8 index[0];
} PACKED;
struct babel_tlv_challenge {
u8 type;
u8 length;
u8 nonce[0];
} PACKED;
struct babel_mac_pseudoheader {
u8 src_addr[16];
u16 src_port;
u8 dst_addr[16];
u16 dst_port;
} PACKED;
/* Hello flags */
#define BABEL_HF_UNICAST 0x8000
/* Update flags */
#define BABEL_UF_DEF_PREFIX 0x80
#define BABEL_UF_ROUTER_ID 0x40
struct babel_parse_state;
struct babel_write_state;
struct babel_tlv_data {
u8 min_length;
int (*read_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_parse_state *state);
uint (*write_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_write_state *state, uint max_len);
void (*handle_tlv)(union babel_msg *m, struct babel_iface *ifa);
};
struct babel_parse_state {
const struct babel_tlv_data* (*get_tlv_data)(u8 type);
const struct babel_tlv_data* (*get_subtlv_data)(u8 type);
struct babel_proto *proto;
struct babel_iface *ifa;
btime received_time;
ip_addr saddr;
ip_addr next_hop_ip4;
ip_addr next_hop_ip6;
u64 router_id; /* Router ID used in subsequent updates */
u8 def_ip6_prefix[16]; /* Implicit IPv6 prefix in network order */
u8 def_ip4_prefix[4]; /* Implicit IPv4 prefix in network order */
u8 router_id_seen; /* router_id field is valid */
u8 def_ip6_prefix_seen; /* def_ip6_prefix is valid */
u8 def_ip4_prefix_seen; /* def_ip4_prefix is valid */
u8 hello_tstamp_seen; /* pkt contains a hello timestamp */
u8 current_tlv_endpos; /* End of self-terminating TLVs (offset from start) */
u8 sadr_enabled;
u8 is_unicast;
struct babel_msg_auth auth;
};
enum parse_result {
PARSE_SUCCESS,
PARSE_ERROR,
PARSE_IGNORE,
};
struct babel_write_state {
u64 router_id;
u8 router_id_seen;
ip_addr next_hop_ip4;
ip_addr next_hop_ip6;
u8 def_ip6_prefix[16]; /* Implicit IPv6 prefix in network order */
u8 def_ip6_pxlen;
};
#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
#define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
#define LOG_PKT(msg, args...) \
log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
#define LOG_WARN(msg, args...) \
log_rl(&p->log_pkt_tbf, L_WARN "%s: " msg, p->p.name, args)
#define LOG_PKT_AUTH(msg, args...) \
log_rl(&p->log_pkt_tbf, L_AUTH "%s: " msg, p->p.name, args)
#define FIRST_TLV(p) ((struct babel_tlv *) (((struct babel_pkt_header *) p) + 1))
#define NEXT_TLV(t) ((struct babel_tlv *) (((byte *) t) + TLV_LENGTH(t)))
#define TLV_LENGTH(t) (t->type == BABEL_TLV_PAD1 ? 1 : t->length + sizeof(struct babel_tlv))
#define TLV_OPT_LENGTH(t) (t->length + sizeof(struct babel_tlv) - sizeof(*t))
#define TLV_HDR(tlv,t,l) ({ tlv->type = t; tlv->length = l - sizeof(struct babel_tlv); })
#define TLV_HDR0(tlv,t) TLV_HDR(tlv, t, tlv_data[t].min_length)
#define NET_SIZE(n) BYTES(net_pxlen(n))
/* Helper macros to loop over a series of TLVs.
* @start pointer to first TLV (void * or struct babel_tlv *)
* @end byte * pointer to TLV stream end
* @tlv struct babel_tlv pointer used as iterator
* @frame_err boolean (u8) that will be set to 1 if a frame error occurred
* @saddr source addr for use in log output
* @ifname ifname for use in log output
*/
#define WALK_TLVS(start, end, tlv, frame_err, saddr, ifname) \
for (tlv = start; \
(byte *)tlv < end; \
tlv = NEXT_TLV(tlv)) \
{ \
byte *loop_pos; \
/* Ugly special case */ \
if (tlv->type == BABEL_TLV_PAD1) \
continue; \
\
/* The end of the common TLV header */ \
loop_pos = (byte *)tlv + sizeof(struct babel_tlv); \
if ((loop_pos > end) || (loop_pos + tlv->length > end)) \
{ \
LOG_PKT("Bad TLV from %I via %s type %d pos %d - framing error", \
saddr, ifname, tlv->type, (int) ((byte *)tlv - (byte *)start)); \
frame_err = 1; \
break; \
}
#define WALK_TLVS_END }
static inline uint
bytes_equal(u8 *b1, u8 *b2, uint maxlen)
{
uint i;
for (i = 0; (i < maxlen) && (*b1 == *b2); i++, b1++, b2++)
;
return i;
}
static inline uint
get_time16(const void *p)
{
uint v = get_u16(p) * BABEL_TIME_UNITS;
return MAX(BABEL_MIN_INTERVAL, v);
}
static inline void
put_time16(void *p, uint v)
{
put_u16(p, v / BABEL_TIME_UNITS);
}
static inline void
read_ip4_px(net_addr *n, const void *p, uint plen)
{
ip4_addr addr = {0};
memcpy(&addr, p, BYTES(plen));
net_fill_ip4(n, ip4_ntoh(addr), plen);
}
static inline void
put_ip4_px(void *p, net_addr *n)
{
ip4_addr addr = ip4_hton(net4_prefix(n));
memcpy(p, &addr, NET_SIZE(n));
}
static inline void
read_ip6_px(net_addr *n, const void *p, uint plen)
{
ip6_addr addr = IPA_NONE;
memcpy(&addr, p, BYTES(plen));
net_fill_ip6(n, ip6_ntoh(addr), plen);
}
static inline void
put_ip6_px(void *p, net_addr *n)
{
ip6_addr addr = ip6_hton(net6_prefix(n));
memcpy(p, &addr, NET_SIZE(n));
}
static inline ip6_addr
get_ip6_ll(const void *p)
{
return ip6_build(0xfe800000, 0, get_u32(p+0), get_u32(p+4));
}
static inline void
put_ip6_ll(void *p, ip6_addr addr)
{
put_u32(p+0, _I2(addr));
put_u32(p+4, _I3(addr));
}
/*
* Authentication-related functions
*/
uint babel_auth_write_challenge(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
int babel_auth_add_tlvs(struct babel_iface *ifa, struct babel_tlv *tlv, uint max_len);
int babel_auth_sign(struct babel_iface *ifa, ip_addr dest);
int babel_auth_check(struct babel_iface *ifa,
ip_addr saddr, u16 sport,
ip_addr daddr, u16 dport,
struct babel_pkt_header *pkt,
byte *start, uint len);
/*
* TLV read/write functions
*/
static int babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_router_id(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_source_prefix(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static int babel_read_timestamp(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
static uint babel_write_ack(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static uint babel_write_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static uint babel_write_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static uint babel_write_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static uint babel_write_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static uint babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
static int babel_write_source_prefix(struct babel_tlv *hdr, net_addr *net, uint max_len);
static int babel_write_timestamp(struct babel_tlv *hdr, u32 tstamp, u32 tstamp_rcvd, uint max_len);
static const struct babel_tlv_data tlv_data[BABEL_TLV_MAX] = {
[BABEL_TLV_ACK_REQ] = {
sizeof(struct babel_tlv_ack_req),
babel_read_ack_req,
NULL,
babel_handle_ack_req
},
[BABEL_TLV_ACK] = {
sizeof(struct babel_tlv_ack),
NULL,
babel_write_ack,
NULL
},
[BABEL_TLV_HELLO] = {
sizeof(struct babel_tlv_hello),
babel_read_hello,
babel_write_hello,
babel_handle_hello
},
[BABEL_TLV_IHU] = {
sizeof(struct babel_tlv_ihu),
babel_read_ihu,
babel_write_ihu,
babel_handle_ihu
},
[BABEL_TLV_ROUTER_ID] = {
sizeof(struct babel_tlv_router_id),
babel_read_router_id,
NULL,
NULL
},
[BABEL_TLV_NEXT_HOP] = {
sizeof(struct babel_tlv_next_hop),
babel_read_next_hop,
NULL,
NULL
},
[BABEL_TLV_UPDATE] = {
sizeof(struct babel_tlv_update),
babel_read_update,
babel_write_update,
babel_handle_update
},
[BABEL_TLV_ROUTE_REQUEST] = {
sizeof(struct babel_tlv_route_request),
babel_read_route_request,
babel_write_route_request,
babel_handle_route_request
},
[BABEL_TLV_SEQNO_REQUEST] = {
sizeof(struct babel_tlv_seqno_request),
babel_read_seqno_request,
babel_write_seqno_request,
babel_handle_seqno_request
},
[BABEL_TLV_CHALLENGE_REQUEST] = {
sizeof(struct babel_tlv_challenge),
NULL,
babel_auth_write_challenge,
NULL
},
[BABEL_TLV_CHALLENGE_REPLY] = {
sizeof(struct babel_tlv_challenge),
NULL,
babel_auth_write_challenge,
NULL
},
};
static const struct babel_tlv_data *get_packet_tlv_data(u8 type)
{
return type < sizeof(tlv_data) / sizeof(*tlv_data) ? &tlv_data[type] : NULL;
}
static const struct babel_tlv_data timestamp_tlv_data = {
sizeof(struct babel_subtlv_timestamp),
babel_read_timestamp,
NULL,
NULL
};
static const struct babel_tlv_data source_prefix_tlv_data = {
sizeof(struct babel_subtlv_source_prefix),
babel_read_source_prefix,
NULL,
NULL
};
static const struct babel_tlv_data *get_packet_subtlv_data(u8 type)
{
switch (type)
{
case BABEL_SUBTLV_TIMESTAMP:
return &timestamp_tlv_data;
case BABEL_SUBTLV_SOURCE_PREFIX:
return &source_prefix_tlv_data;
default:
return NULL;
}
}
static int
babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_ack_req *tlv = (void *) hdr;
struct babel_msg_ack_req *msg = &m->ack_req;
msg->type = BABEL_TLV_ACK_REQ;
msg->nonce = get_u16(&tlv->nonce);
msg->interval = get_time16(&tlv->interval);
msg->sender = state->saddr;
if (!msg->interval)
return PARSE_ERROR;
return PARSE_SUCCESS;
}
static uint
babel_write_ack(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len UNUSED)
{
struct babel_tlv_ack *tlv = (void *) hdr;
struct babel_msg_ack *msg = &m->ack;
TLV_HDR0(tlv, BABEL_TLV_ACK);
put_u16(&tlv->nonce, msg->nonce);
return sizeof(struct babel_tlv_ack);
}
static int
babel_read_hello(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_hello *tlv = (void *) hdr;
struct babel_msg_hello *msg = &m->hello;
/* We currently don't support unicast Hello */
u16 flags = get_u16(&tlv->flags);
if (flags & BABEL_HF_UNICAST)
return PARSE_IGNORE;
msg->type = BABEL_TLV_HELLO;
msg->seqno = get_u16(&tlv->seqno);
msg->interval = get_time16(&tlv->interval);
msg->sender = state->saddr;
return PARSE_SUCCESS;
}
static uint
babel_write_hello(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len)
{
struct babel_tlv_hello *tlv = (void *) hdr;
struct babel_msg_hello *msg = &m->hello;
uint len = sizeof(struct babel_tlv_hello);
TLV_HDR0(tlv, BABEL_TLV_HELLO);
put_u16(&tlv->seqno, msg->seqno);
put_time16(&tlv->interval, msg->interval);
if (msg->tstamp)
{
/*
* There can be a substantial delay between when the babel_msg was created
* and when it is serialised. We don't want this included in the RTT
* measurement, so replace the timestamp with the current time to get as
* close as possible to on-wire time for the packet.
*/
u32 tstamp = current_time_now() TO_US;
int l = babel_write_timestamp(hdr, tstamp, 0, max_len);
if (l < 0)
return 0;
len += l;
}
return len;
}
static int
babel_read_ihu(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_ihu *tlv = (void *) hdr;
struct babel_msg_ihu *msg = &m->ihu;
msg->type = BABEL_TLV_IHU;
msg->ae = tlv->ae;
msg->rxcost = get_u16(&tlv->rxcost);
msg->interval = get_time16(&tlv->interval);
msg->addr = IPA_NONE;
msg->sender = state->saddr;
if (msg->ae >= BABEL_AE_MAX)
return PARSE_IGNORE;
/*
* We only actually read link-local IPs. In every other case, the addr field
* will be 0 but validation will succeed. The handler takes care of these
* cases. We handle them here anyway because we need the length for parsing
* subtlvs.
*/
switch (msg->ae)
{
case BABEL_AE_IP4:
if (TLV_OPT_LENGTH(tlv) < 4)
return PARSE_ERROR;
state->current_tlv_endpos += 4;
break;
case BABEL_AE_IP6:
if (TLV_OPT_LENGTH(tlv) < 16)
return PARSE_ERROR;
state->current_tlv_endpos += 16;
break;
case BABEL_AE_IP6_LL:
if (TLV_OPT_LENGTH(tlv) < 8)
return PARSE_ERROR;
msg->addr = ipa_from_ip6(get_ip6_ll(&tlv->addr));
state->current_tlv_endpos += 8;
break;
}
return PARSE_SUCCESS;
}
static uint
babel_write_ihu(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len)
{
struct babel_tlv_ihu *tlv = (void *) hdr;
struct babel_msg_ihu *msg = &m->ihu;
uint len = sizeof(*tlv);
if (ipa_is_link_local(msg->addr) && max_len < sizeof(struct babel_tlv_ihu) + 8)
return 0;
TLV_HDR0(tlv, BABEL_TLV_IHU);
put_u16(&tlv->rxcost, msg->rxcost);
put_time16(&tlv->interval, msg->interval);
if (!ipa_is_link_local(msg->addr))
{
tlv->ae = BABEL_AE_WILDCARD;
goto out;
}
put_ip6_ll(&tlv->addr, msg->addr);
tlv->ae = BABEL_AE_IP6_LL;
hdr->length += 8;
len += 8;
out:
if (msg->tstamp)
{
int l = babel_write_timestamp(hdr, msg->tstamp, msg->tstamp_rcvd, max_len);
if (l < 0)
return 0;
len += l;
}
return len;
}
static int
babel_read_router_id(struct babel_tlv *hdr, union babel_msg *m UNUSED,
struct babel_parse_state *state)
{
struct babel_tlv_router_id *tlv = (void *) hdr;
state->router_id = get_u64(&tlv->router_id);
state->router_id_seen = 1;
return PARSE_IGNORE;
}
/* This is called directly from babel_write_update() */
static uint
babel_write_router_id(struct babel_tlv *hdr, u64 router_id,
struct babel_write_state *state, uint max_len UNUSED)
{
struct babel_tlv_router_id *tlv = (void *) hdr;
/* We still assume that first min_length bytes are available and zeroed */
TLV_HDR0(tlv, BABEL_TLV_ROUTER_ID);
put_u64(&tlv->router_id, router_id);
state->router_id = router_id;
state->router_id_seen = 1;
return sizeof(struct babel_tlv_router_id);
}
static int
babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *m UNUSED,
struct babel_parse_state *state)
{
struct babel_tlv_next_hop *tlv = (void *) hdr;
switch (tlv->ae)
{
case BABEL_AE_WILDCARD:
return PARSE_ERROR;
case BABEL_AE_IP4:
if (TLV_OPT_LENGTH(tlv) < sizeof(ip4_addr))
return PARSE_ERROR;
state->next_hop_ip4 = ipa_from_ip4(get_ip4(&tlv->addr));
state->current_tlv_endpos += sizeof(ip4_addr);
return PARSE_IGNORE;
case BABEL_AE_IP6:
if (TLV_OPT_LENGTH(tlv) < sizeof(ip6_addr))
return PARSE_ERROR;
state->next_hop_ip6 = ipa_from_ip6(get_ip6(&tlv->addr));
state->current_tlv_endpos += sizeof(ip6_addr);
return PARSE_IGNORE;
case BABEL_AE_IP6_LL:
if (TLV_OPT_LENGTH(tlv) < 8)
return PARSE_ERROR;
state->next_hop_ip6 = ipa_from_ip6(get_ip6_ll(&tlv->addr));
state->current_tlv_endpos += 8;
return PARSE_IGNORE;
default:
return PARSE_IGNORE;
}
return PARSE_IGNORE;
}
/* This is called directly from babel_write_update() and returns -1 if a next
hop should be written but there is not enough space. */
static int
babel_write_next_hop(struct babel_tlv *hdr, ip_addr addr,
struct babel_write_state *state, uint max_len)
{
struct babel_tlv_next_hop *tlv = (void *) hdr;
if (ipa_zero(addr))
{
/* Should not happen */
return 0;
}
else if (ipa_is_ip4(addr) && !ipa_equal(addr, state->next_hop_ip4))
{
uint len = sizeof(struct babel_tlv_next_hop) + sizeof(ip4_addr);
if (len > max_len)
return -1;
TLV_HDR(tlv, BABEL_TLV_NEXT_HOP, len);
tlv->ae = BABEL_AE_IP4;
put_ip4(&tlv->addr, ipa_to_ip4(addr));
state->next_hop_ip4 = addr;
return len;
}
else if (ipa_is_ip6(addr) && !ipa_equal(addr, state->next_hop_ip6))
{
uint len = sizeof(struct babel_tlv_next_hop) + sizeof(ip6_addr);
if (len > max_len)
return -1;
TLV_HDR(tlv, BABEL_TLV_NEXT_HOP, len);
tlv->ae = BABEL_AE_IP6;
put_ip6(&tlv->addr, ipa_to_ip6(addr));
state->next_hop_ip6 = addr;
return len;
}
return 0;
}
static int
babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_update *tlv = (void *) hdr;
struct babel_msg_update *msg = &m->update;
msg->type = BABEL_TLV_UPDATE;
msg->interval = get_time16(&tlv->interval);
msg->seqno = get_u16(&tlv->seqno);
msg->metric = get_u16(&tlv->metric);
/* Length of received prefix data without omitted part */
int len = BYTES(tlv->plen) - (int) tlv->omitted;
u8 buf[16] = {};
if ((len < 0) || ((uint) len > TLV_OPT_LENGTH(tlv)))
return PARSE_ERROR;
switch (tlv->ae)
{
case BABEL_AE_WILDCARD:
if (tlv->plen > 0)
return PARSE_ERROR;
if (msg->metric != 65535)
return PARSE_ERROR;
msg->wildcard = 1;
break;
case BABEL_AE_IP4:
if (tlv->plen > IP4_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
/* Cannot omit data if there is no saved prefix */
if (tlv->omitted && !state->def_ip4_prefix_seen)
return PARSE_ERROR;
/* Update must have next hop, unless it is retraction */
if (ipa_zero(state->next_hop_ip4) && (msg->metric != BABEL_INFINITY))
return PARSE_IGNORE;
/* Merge saved prefix and received prefix parts */
memcpy(buf, state->def_ip4_prefix, tlv->omitted);
memcpy(buf + tlv->omitted, tlv->addr, len);
ip4_addr prefix4 = get_ip4(buf);
net_fill_ip4(&msg->net, prefix4, tlv->plen);
if (tlv->flags & BABEL_UF_DEF_PREFIX)
{
put_ip4(state->def_ip4_prefix, prefix4);
state->def_ip4_prefix_seen = 1;
}
msg->next_hop = state->next_hop_ip4;
break;
case BABEL_AE_IP6:
if (tlv->plen > IP6_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
/* Cannot omit data if there is no saved prefix */
if (tlv->omitted && !state->def_ip6_prefix_seen)
return PARSE_ERROR;
/* Merge saved prefix and received prefix parts */
memcpy(buf, state->def_ip6_prefix, tlv->omitted);
memcpy(buf + tlv->omitted, tlv->addr, len);
ip6_addr prefix6 = get_ip6(buf);
net_fill_ip6(&msg->net, prefix6, tlv->plen);
if (state->sadr_enabled)
net_make_ip6_sadr(&msg->net);
if (tlv->flags & BABEL_UF_DEF_PREFIX)
{
put_ip6(state->def_ip6_prefix, prefix6);
state->def_ip6_prefix_seen = 1;
}
if (tlv->flags & BABEL_UF_ROUTER_ID)
{
state->router_id = ((u64) _I2(prefix6)) << 32 | _I3(prefix6);
state->router_id_seen = 1;
}
msg->next_hop = state->next_hop_ip6;
break;
case BABEL_AE_IP6_LL:
/* ??? */
return PARSE_IGNORE;
default:
return PARSE_IGNORE;
}
/* Update must have Router ID, unless it is retraction */
if (!state->router_id_seen && (msg->metric != BABEL_INFINITY))
{
DBG("Babel: No router ID seen before update\n");
return PARSE_ERROR;
}
msg->router_id = state->router_id;
msg->sender = state->saddr;
state->current_tlv_endpos += len;
return PARSE_SUCCESS;
}
static uint
babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state, uint max_len)
{
struct babel_msg_update *msg = &m->update;
uint len0 = 0;
/*
* When needed, we write Router-ID TLV before Update TLV and return size of
* both of them. There is enough space for the Router-ID TLV, because
* sizeof(struct babel_tlv_router_id) == sizeof(struct babel_tlv_update).
*
* Router ID is not used for retractions, so do not use it in such case.
*/
if ((msg->metric < BABEL_INFINITY) &&
(!state->router_id_seen || (msg->router_id != state->router_id)))
{
len0 = babel_write_router_id(hdr, msg->router_id, state, max_len);
hdr = NEXT_TLV(hdr);
}
/*
* We also may add Next Hop TLV for regular updates. It may fail for not
* enough space or it may be unnecessary as the next hop is the same as the
* last one already announced. So we handle all three cases.
*/
if (msg->metric < BABEL_INFINITY)
{
int l = babel_write_next_hop(hdr, msg->next_hop, state, max_len - len0);
if (l < 0)
return 0;
if (l)
{
len0 += l;
hdr = NEXT_TLV(hdr);
}
}
struct babel_tlv_update *tlv = (void *) hdr;
uint len = sizeof(struct babel_tlv_update) + NET_SIZE(&msg->net);
if (len0 + len > max_len)
return 0;
memset(tlv, 0, sizeof(struct babel_tlv_update));
TLV_HDR(tlv, BABEL_TLV_UPDATE, len);
if (msg->wildcard)
{
tlv->ae = BABEL_AE_WILDCARD;
tlv->plen = 0;
}
else if (msg->net.type == NET_IP4)
{
tlv->ae = BABEL_AE_IP4;
tlv->plen = net4_pxlen(&msg->net);
put_ip4_px(tlv->addr, &msg->net);
}
else
{
tlv->ae = BABEL_AE_IP6;
tlv->plen = net6_pxlen(&msg->net);
/* Address compression - omit initial matching bytes */
u8 buf[16], omit;
put_ip6(buf, net6_prefix(&msg->net));
omit = bytes_equal(buf, state->def_ip6_prefix,
MIN(tlv->plen, state->def_ip6_pxlen) / 8);
if (omit > 0)
{
memcpy(tlv->addr, buf + omit, NET_SIZE(&msg->net) - omit);
tlv->omitted = omit;
tlv->length -= omit;
len -= omit;
}
else
{
put_ip6_px(tlv->addr, &msg->net);
tlv->flags |= BABEL_UF_DEF_PREFIX;
put_ip6(state->def_ip6_prefix, net6_prefix(&msg->net));
state->def_ip6_pxlen = tlv->plen;
}
}
put_time16(&tlv->interval, msg->interval);
put_u16(&tlv->seqno, msg->seqno);
put_u16(&tlv->metric, msg->metric);
if (msg->net.type == NET_IP6_SADR)
{
int l = babel_write_source_prefix(hdr, &msg->net, max_len - (len0 + len));
if (l < 0)
return 0;
len += l;
}
return len0 + len;
}
static int
babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_route_request *tlv = (void *) hdr;
struct babel_msg_route_request *msg = &m->route_request;
msg->type = BABEL_TLV_ROUTE_REQUEST;
switch (tlv->ae)
{
case BABEL_AE_WILDCARD:
/* Wildcard requests must have plen 0 */
if (tlv->plen > 0)
return PARSE_ERROR;
msg->full = 1;
return PARSE_SUCCESS;
case BABEL_AE_IP4:
if (tlv->plen > IP4_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
return PARSE_ERROR;
read_ip4_px(&msg->net, tlv->addr, tlv->plen);
state->current_tlv_endpos += BYTES(tlv->plen);
return PARSE_SUCCESS;
case BABEL_AE_IP6:
if (tlv->plen > IP6_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
return PARSE_ERROR;
read_ip6_px(&msg->net, tlv->addr, tlv->plen);
state->current_tlv_endpos += BYTES(tlv->plen);
if (state->sadr_enabled)
net_make_ip6_sadr(&msg->net);
return PARSE_SUCCESS;
case BABEL_AE_IP6_LL:
return PARSE_ERROR;
default:
return PARSE_IGNORE;
}
return PARSE_IGNORE;
}
static uint
babel_write_route_request(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len)
{
struct babel_tlv_route_request *tlv = (void *) hdr;
struct babel_msg_route_request *msg = &m->route_request;
uint len = sizeof(struct babel_tlv_route_request) + NET_SIZE(&msg->net);
if (len > max_len)
return 0;
TLV_HDR(tlv, BABEL_TLV_ROUTE_REQUEST, len);
if (msg->full)
{
tlv->ae = BABEL_AE_WILDCARD;
tlv->plen = 0;
}
else if (msg->net.type == NET_IP4)
{
tlv->ae = BABEL_AE_IP4;
tlv->plen = net4_pxlen(&msg->net);
put_ip4_px(tlv->addr, &msg->net);
}
else
{
tlv->ae = BABEL_AE_IP6;
tlv->plen = net6_pxlen(&msg->net);
put_ip6_px(tlv->addr, &msg->net);
}
if (msg->net.type == NET_IP6_SADR)
{
int l = babel_write_source_prefix(hdr, &msg->net, max_len - len);
if (l < 0)
return 0;
len += l;
}
return len;
}
static int
babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
struct babel_parse_state *state)
{
struct babel_tlv_seqno_request *tlv = (void *) hdr;
struct babel_msg_seqno_request *msg = &m->seqno_request;
msg->type = BABEL_TLV_SEQNO_REQUEST;
msg->seqno = get_u16(&tlv->seqno);
msg->hop_count = tlv->hop_count;
msg->router_id = get_u64(&tlv->router_id);
msg->sender = state->saddr;
if (tlv->hop_count == 0)
return PARSE_ERROR;
switch (tlv->ae)
{
case BABEL_AE_WILDCARD:
return PARSE_ERROR;
case BABEL_AE_IP4:
if (tlv->plen > IP4_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
return PARSE_ERROR;
read_ip4_px(&msg->net, tlv->addr, tlv->plen);
state->current_tlv_endpos += BYTES(tlv->plen);
return PARSE_SUCCESS;
case BABEL_AE_IP6:
if (tlv->plen > IP6_MAX_PREFIX_LENGTH)
return PARSE_ERROR;
if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
return PARSE_ERROR;
read_ip6_px(&msg->net, tlv->addr, tlv->plen);
state->current_tlv_endpos += BYTES(tlv->plen);
if (state->sadr_enabled)
net_make_ip6_sadr(&msg->net);
return PARSE_SUCCESS;
case BABEL_AE_IP6_LL:
return PARSE_ERROR;
default:
return PARSE_IGNORE;
}
return PARSE_IGNORE;
}
static uint
babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len)
{
struct babel_tlv_seqno_request *tlv = (void *) hdr;
struct babel_msg_seqno_request *msg = &m->seqno_request;
uint len = sizeof(struct babel_tlv_seqno_request) + NET_SIZE(&msg->net);
if (len > max_len)
return 0;
TLV_HDR(tlv, BABEL_TLV_SEQNO_REQUEST, len);
if (msg->net.type == NET_IP4)
{
tlv->ae = BABEL_AE_IP4;
tlv->plen = net4_pxlen(&msg->net);
put_ip4_px(tlv->addr, &msg->net);
}
else
{
tlv->ae = BABEL_AE_IP6;
tlv->plen = net6_pxlen(&msg->net);
put_ip6_px(tlv->addr, &msg->net);
}
put_u16(&tlv->seqno, msg->seqno);
tlv->hop_count = msg->hop_count;
put_u64(&tlv->router_id, msg->router_id);
if (msg->net.type == NET_IP6_SADR)
{
int l = babel_write_source_prefix(hdr, &msg->net, max_len - len);
if (l < 0)
return 0;
len += l;
}
return len;
}
static int
babel_read_source_prefix(struct babel_tlv *hdr, union babel_msg *msg,
struct babel_parse_state *state UNUSED)
{
struct babel_subtlv_source_prefix *tlv = (void *) hdr;
net_addr_ip6_sadr *net;
/*
* We would like to skip the sub-TLV if SADR is not enabled, but we do not
* know AF of the enclosing TLV yet. We will do that later.
*/
/* Check internal consistency */
if ((tlv->length < 1) ||
(tlv->plen > IP6_MAX_PREFIX_LENGTH) ||
(tlv->length < (1 + BYTES(tlv->plen))))
return PARSE_ERROR;
/* Plen MUST NOT be 0 */
if (tlv->plen == 0)
return PARSE_ERROR;
switch (msg->type)
{
case BABEL_TLV_UPDATE:
/* Wildcard updates with source prefix MUST be silently ignored */
if (msg->update.wildcard)
return PARSE_IGNORE;
net = (void *) &msg->update.net;
break;
case BABEL_TLV_ROUTE_REQUEST:
/* Wildcard requests with source addresses MUST be silently ignored */
if (msg->route_request.full)
return PARSE_IGNORE;
net = (void *) &msg->route_request.net;
break;
case BABEL_TLV_SEQNO_REQUEST:
net = (void *) &msg->seqno_request.net;
break;
default:
return PARSE_ERROR;
}
/* If SADR is active, the net has appropriate type */
if (net->type != NET_IP6_SADR)
return PARSE_IGNORE;
/* Duplicate Source Prefix sub-TLV; SHOULD ignore whole TLV */
if (net->src_pxlen > 0)
return PARSE_IGNORE;
net_addr_ip6 src;
read_ip6_px((void *) &src, tlv->addr, tlv->plen);
net->src_prefix = src.prefix;
net->src_pxlen = src.pxlen;
return PARSE_SUCCESS;
}
static int
babel_write_source_prefix(struct babel_tlv *hdr, net_addr *n, uint max_len)
{
struct babel_subtlv_source_prefix *tlv = (void *) NEXT_TLV(hdr);
net_addr_ip6_sadr *net = (void *) n;
/* Do not use this sub-TLV for default prefix */
if (net->src_pxlen == 0)
return 0;
uint len = sizeof(*tlv) + BYTES(net->src_pxlen);
if (len > max_len)
return -1;
TLV_HDR(tlv, BABEL_SUBTLV_SOURCE_PREFIX, len);
hdr->length += len;
net_addr_ip6 src = NET_ADDR_IP6(net->src_prefix, net->src_pxlen);
tlv->plen = src.pxlen;
put_ip6_px(tlv->addr, (void *) &src);
return len;
}
static int
babel_read_timestamp(struct babel_tlv *hdr, union babel_msg *msg,
struct babel_parse_state *state)
{
struct babel_subtlv_timestamp *tlv = (void *) hdr;
switch (msg->type)
{
case BABEL_TLV_HELLO:
if (tlv->length < 4)
return PARSE_ERROR;
msg->hello.tstamp = get_u32(&tlv->tstamp);
msg->hello.pkt_received = state->received_time;
state->hello_tstamp_seen = 1;
break;
case BABEL_TLV_IHU:
if (tlv->length < 8)
return PARSE_ERROR;
/* RTT calculation relies on a Hello always being present with an IHU */
if (!state->hello_tstamp_seen)
break;
msg->ihu.tstamp = get_u32(&tlv->tstamp);
msg->ihu.tstamp_rcvd = get_u32(&tlv->tstamp_rcvd);
msg->ihu.pkt_received = state->received_time;
break;
default:
return PARSE_ERROR;
}
return PARSE_SUCCESS;
}
static int
babel_write_timestamp(struct babel_tlv *hdr, u32 tstamp, u32 tstamp_rcvd, uint max_len)
{
struct babel_subtlv_timestamp *tlv = (void *) NEXT_TLV(hdr);
uint len = sizeof(*tlv);
if (hdr->type == BABEL_TLV_HELLO)
len -= 4;
if (len > max_len)
return -1;
TLV_HDR(tlv, BABEL_SUBTLV_TIMESTAMP, len);
hdr->length += len;
put_u32(&tlv->tstamp, tstamp);
if (hdr->type == BABEL_TLV_IHU)
put_u32(&tlv->tstamp_rcvd, tstamp_rcvd);
return len;
}
static inline int
babel_read_subtlvs(struct babel_tlv *hdr,
union babel_msg *msg,
struct babel_parse_state *state)
{
const struct babel_tlv_data *tlv_data;
struct babel_proto *p = state->proto;
struct babel_tlv *tlv;
byte *end = (byte *) hdr + TLV_LENGTH(hdr);
u8 frame_err = 0;
int res;
WALK_TLVS((void *)hdr + state->current_tlv_endpos, end, tlv, frame_err,
state->saddr, state->ifa->ifname)
{
if (tlv->type == BABEL_SUBTLV_PADN)
continue;
if (!state->get_subtlv_data ||
!(tlv_data = state->get_subtlv_data(tlv->type)) ||
!tlv_data->read_tlv)
{
/* Unknown mandatory subtlv; PARSE_IGNORE ignores the whole TLV */
if (tlv->type >= 128)
return PARSE_IGNORE;
continue;
}
res = tlv_data->read_tlv(tlv, msg, state);
if (res != PARSE_SUCCESS)
return res;
}
WALK_TLVS_END;
return frame_err ? PARSE_ERROR : PARSE_SUCCESS;
}
static int
babel_read_tlv(struct babel_tlv *hdr,
union babel_msg *msg,
struct babel_parse_state *state)
{
const struct babel_tlv_data *tlv_data;
if ((hdr->type <= BABEL_TLV_PADN) ||
(hdr->type >= BABEL_TLV_MAX))
return PARSE_IGNORE;
tlv_data = state->get_tlv_data(hdr->type);
if (!tlv_data || !tlv_data->read_tlv)
return PARSE_IGNORE;
if (TLV_LENGTH(hdr) < tlv_data->min_length)
return PARSE_ERROR;
state->current_tlv_endpos = tlv_data->min_length;
int res = tlv_data->read_tlv(hdr, msg, state);
if (res != PARSE_SUCCESS)
return res;
return babel_read_subtlvs(hdr, msg, state);
}
static uint
babel_write_tlv(struct babel_tlv *hdr,
union babel_msg *msg,
struct babel_write_state *state,
uint max_len)
{
if ((msg->type <= BABEL_TLV_PADN) ||
(msg->type >= BABEL_TLV_MAX) ||
!tlv_data[msg->type].write_tlv)
return 0;
if (tlv_data[msg->type].min_length > max_len)
return 0;
memset(hdr, 0, tlv_data[msg->type].min_length);
return tlv_data[msg->type].write_tlv(hdr, msg, state, max_len);
}
/*
* Packet RX/TX functions
*/
static int
babel_send_to(struct babel_iface *ifa, ip_addr dest)
{
sock *sk = ifa->sk;
struct babel_pkt_header *hdr = (void *) sk->tbuf;
int len = get_u16(&hdr->length) + sizeof(struct babel_pkt_header);
len += babel_auth_sign(ifa, dest);
DBG("Babel: Sending %d bytes to %I\n", len, dest);
return sk_send_to(sk, len, dest, 0);
}
/**
* babel_write_queue - Write a TLV queue to a transmission buffer
* @ifa: Interface holding the transmission buffer
* @queue: TLV queue to write (containing internal-format TLVs)
*
* This function writes a packet to the interface transmission buffer with as
* many TLVs from the &queue as will fit in the buffer. It returns the number of
* bytes written (NOT counting the packet header). The function is called by
* babel_send_queue() and babel_send_unicast() to construct packets for
* transmission, and uses per-TLV helper functions to convert the
* internal-format TLVs to their wire representations.
*
* The TLVs in the queue are freed after they are written to the buffer.
*/
static uint
babel_write_queue(struct babel_iface *ifa, list *queue)
{
struct babel_proto *p = ifa->proto;
struct babel_write_state state = { .next_hop_ip6 = ifa->addr };
if (EMPTY_LIST(*queue))
return 0;
byte *pos = ifa->sk->tbuf;
byte *end = pos + ifa->tx_length;
struct babel_pkt_header *pkt = (void *) pos;
pkt->magic = BABEL_MAGIC;
pkt->version = BABEL_VERSION;
pkt->length = 0;
pos += sizeof(struct babel_pkt_header);
struct babel_msg_node *msg;
WALK_LIST_FIRST(msg, *queue)
{
if (pos >= end)
break;
int len = babel_write_tlv((struct babel_tlv *) pos, &msg->msg, &state, end - pos);
if (!len)
break;
pos += len;
rem_node(NODE msg);
sl_free(p->msg_slab, msg);
}
pos += babel_auth_add_tlvs(ifa, (struct babel_tlv *) pos, end - pos);
uint plen = pos - (byte *) pkt;
put_u16(&pkt->length, plen - sizeof(struct babel_pkt_header));
return plen;
}
void
babel_send_queue(void *arg)
{
struct babel_iface *ifa = arg;
while ((babel_write_queue(ifa, &ifa->msg_queue) > 0) &&
(babel_send_to(ifa, IP6_BABEL_ROUTERS) > 0));
}
static inline void
babel_kick_queue(struct babel_iface *ifa)
{
/*
* Only schedule send event if there is not already data in the socket buffer.
* Otherwise we may overwrite the data already in the buffer.
*/
if ((ifa->sk->tpos == ifa->sk->tbuf) && !ev_active(ifa->send_event))
ev_schedule(ifa->send_event);
}
/**
* babel_send_unicast - send a single TLV via unicast to a destination
* @msg: TLV to send
* @ifa: Interface to send via
* @dest: Destination of the TLV
*
* This function is used to send a single TLV via unicast to a designated
* receiver. This is used for replying to certain incoming requests, and for
* sending unicast requests to refresh routes before they expire.
*/
void
babel_send_unicast(union babel_msg *msg, struct babel_iface *ifa, ip_addr dest)
{
struct babel_proto *p = ifa->proto;
struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
list queue;
*msgn = (struct babel_msg_node) { .msg = *msg };
init_list(&queue);
add_tail(&queue, NODE msgn);
babel_write_queue(ifa, &queue);
babel_send_to(ifa, dest);
/* We could overwrite waiting packet here, we may have to kick TX queue */
if (!EMPTY_LIST(ifa->msg_queue))
babel_kick_queue(ifa);
}
/**
* babel_enqueue - enqueue a TLV for transmission on an interface
* @msg: TLV to enqueue (in internal TLV format)
* @ifa: Interface to enqueue to
*
* This function is called to enqueue a TLV for subsequent transmission on an
* interface. The transmission event is triggered whenever a TLV is enqueued;
* this ensures that TLVs will be transmitted in a timely manner, but that TLVs
* which are enqueued in rapid succession can be transmitted together in one
* packet.
*/
void
babel_enqueue(union babel_msg *msg, struct babel_iface *ifa)
{
struct babel_proto *p = ifa->proto;
struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
*msgn = (struct babel_msg_node) { .msg = *msg };
add_tail(&ifa->msg_queue, NODE msgn);
babel_kick_queue(ifa);
}
/**
* babel_process_packet - process incoming data packet
* @ifa: Interface packet was received on
* @pkt: Pointer to the packet data
* @len: Length of received packet
* @saddr: Address of packet sender
* @sport: Packet source port
* @daddr: Destination address of packet
* @dport: Packet destination port
*
* This function is the main processing hook of incoming Babel packets. It
* checks that the packet header is well-formed, then processes the TLVs
* contained in the packet. This is done in two passes: First all TLVs are
* parsed into the internal TLV format. If a TLV parser fails, processing of the
* rest of the packet is aborted.
*
* After the parsing step, the TLV handlers are called for each parsed TLV in
* order.
*/
static void
babel_process_packet(struct babel_iface *ifa,
struct babel_pkt_header *pkt, int len,
ip_addr saddr, u16 sport,
ip_addr daddr, u16 dport)
{
u8 frame_err UNUSED = 0;
struct babel_proto *p = ifa->proto;
struct babel_tlv *tlv;
struct babel_msg_node *msg;
list msgs;
int res;
int plen = sizeof(struct babel_pkt_header) + get_u16(&pkt->length);
byte *end = (byte *)pkt + plen;
struct babel_parse_state state = {
.get_tlv_data = &get_packet_tlv_data,
.get_subtlv_data = &get_packet_subtlv_data,
.proto = p,
.ifa = ifa,
.saddr = saddr,
.next_hop_ip6 = saddr,
.sadr_enabled = babel_sadr_enabled(p),
/*
* The core updates current_time() after returning from poll(), so this is
* actually the time the packet was received, even though there may have
* been a bit of delay before we got to process it
*/
.received_time = current_time(),
};
if ((pkt->magic != BABEL_MAGIC) || (pkt->version != BABEL_VERSION))
{
TRACE(D_PACKETS, "Strange packet from %I via %s - magic %d version %d",
saddr, ifa->iface->name, pkt->magic, pkt->version);
return;
}
if (plen > len)
{
LOG_PKT("Bad packet from %I via %s - %s (%u)",
saddr, ifa->iface->name, "length mismatch", plen);
return;
}
TRACE(D_PACKETS, "Packet received from %I via %s",
saddr, ifa->iface->name);
if (!babel_auth_check(ifa, saddr, sport, daddr, dport, pkt, end, len - plen))
return;
init_list(&msgs);
/* First pass through the packet TLV by TLV, parsing each into internal data
structures. */
WALK_TLVS(FIRST_TLV(pkt), end, tlv, frame_err, saddr, ifa->iface->name)
{
msg = sl_allocz(p->msg_slab);
res = babel_read_tlv(tlv, &msg->msg, &state);
if (res == PARSE_SUCCESS)
{
add_tail(&msgs, NODE msg);
}
else if (res == PARSE_IGNORE)
{
DBG("Babel: Ignoring TLV of type %d\n", tlv->type);
sl_free(p->msg_slab, msg);
}
else /* PARSE_ERROR */
{
LOG_PKT("Bad TLV from %I via %s type %d pos %d - parse error",
saddr, ifa->iface->name, tlv->type, (int) ((byte *)tlv - (byte *)pkt));
sl_free(p->msg_slab, msg);
break;
}
}
WALK_TLVS_END;
/* Parsing done, handle all parsed TLVs, regardless of any errors */
WALK_LIST_FIRST(msg, msgs)
{
if (tlv_data[msg->msg.type].handle_tlv)
tlv_data[msg->msg.type].handle_tlv(&msg->msg, ifa);
rem_node(NODE msg);
sl_free(p->msg_slab, msg);
}
}
static void
babel_err_hook(sock *sk, int err)
{
struct babel_iface *ifa = sk->data;
struct babel_proto *p = ifa->proto;
log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
/* FIXME: Drop queued TLVs here? */
}
static void
babel_tx_hook(sock *sk)
{
struct babel_iface *ifa = sk->data;
DBG("Babel: TX hook called (iface %s, src %I, dst %I)\n",
sk->iface->name, sk->saddr, sk->daddr);
babel_send_queue(ifa);
}
static int
babel_rx_hook(sock *sk, uint len)
{
struct babel_iface *ifa = sk->data;
struct babel_proto *p = ifa->proto;
const char *err_dsc = NULL;
uint err_val = 0;
if (sk->lifindex != ifa->iface->index)
return 1;
DBG("Babel: RX hook called (iface %s, src %I, dst %I)\n",
sk->iface->name, sk->faddr, sk->laddr);
/* Silently ignore my own packets */
if (ipa_equal(sk->faddr, sk->saddr))
return 1;
if (!ipa_is_link_local(sk->faddr))
DROP1("wrong src address");
if (sk->fport != ifa->cf->port)
DROP("wrong src port", sk->fport);
if (len < sizeof(struct babel_pkt_header))
DROP("too short", len);
if (sk->flags & SKF_TRUNCATED)
DROP("truncated", len);
babel_process_packet(ifa,
(struct babel_pkt_header *) sk->rbuf, len,
sk->faddr, sk->fport,
sk->laddr, sk->dport);
return 1;
drop:
LOG_PKT("Bad packet from %I via %s - %s (%u)",
sk->faddr, sk->iface->name, err_dsc, err_val);
return 1;
}
int
babel_open_socket(struct babel_iface *ifa)
{
struct babel_proto *p = ifa->proto;
sock *sk;
sk = sk_new(ifa->pool);
sk->type = SK_UDP;
sk->sport = ifa->cf->port;
sk->dport = ifa->cf->port;
sk->iface = ifa->iface;
sk->saddr = ifa->addr;
sk->vrf = p->p.vrf;
sk->rx_hook = babel_rx_hook;
sk->tx_hook = babel_tx_hook;
sk->err_hook = babel_err_hook;
sk->data = ifa;
sk->tos = ifa->cf->tx_tos;
sk->priority = ifa->cf->tx_priority;
sk->ttl = 1;
sk->flags = SKF_LADDR_RX;
if (sk_open(sk) < 0)
goto err;
if (sk_setup_multicast(sk) < 0)
goto err;
if (sk_join_group(sk, IP6_BABEL_ROUTERS) < 0)
goto err;
ifa->sk = sk;
return 1;
err:
sk_log_error(sk, p->p.name);
rfree(sk);
return 0;
}
/* Authentication checks */
static int
babel_read_pc(struct babel_tlv *hdr, union babel_msg *m UNUSED,
struct babel_parse_state *state)
{
struct babel_tlv_pc *tlv = (void *) hdr;
/* RFC 8967 4.3 (3) - If multiple PCs are found, only the first one is used */
if (state->auth.pc_seen)
return PARSE_IGNORE;
uint index_len = TLV_OPT_LENGTH(tlv);
if (index_len > BABEL_AUTH_INDEX_LEN)
return PARSE_IGNORE;
state->auth.pc = get_u32(&tlv->pc);
state->auth.pc_seen = 1;
state->auth.index_len = index_len;
state->auth.index = tlv->index;
state->current_tlv_endpos += index_len;
return PARSE_SUCCESS;
}
static const struct babel_tlv_data pc_tlv_data = {
.min_length = sizeof(struct babel_tlv_pc),
.read_tlv = &babel_read_pc
};
static int
babel_read_challenge_req(struct babel_tlv *hdr, union babel_msg *m UNUSED,
struct babel_parse_state *state)
{
struct babel_tlv_challenge *tlv = (void *) hdr;
if (!state->is_unicast)
return PARSE_IGNORE;
uint nonce_len = TLV_OPT_LENGTH(tlv);
if (nonce_len > BABEL_AUTH_MAX_NONCE_LEN)
return PARSE_IGNORE;
state->auth.challenge_len = nonce_len;
bmemcpy(state->auth.challenge, tlv->nonce, nonce_len);
state->auth.challenge_seen = 1;
state->current_tlv_endpos += nonce_len;
return PARSE_SUCCESS;
}
static const struct babel_tlv_data challenge_req_tlv_data = {
.min_length = sizeof(struct babel_tlv_challenge),
.read_tlv = &babel_read_challenge_req,
};
static int
babel_read_challenge_reply(struct babel_tlv *hdr, union babel_msg *m UNUSED,
struct babel_parse_state *state)
{
struct babel_tlv_challenge *tlv = (void *) hdr;
if (state->auth.challenge_reply_seen)
return PARSE_IGNORE;
uint nonce_len = TLV_OPT_LENGTH(tlv);
if (nonce_len != BABEL_AUTH_NONCE_LEN)
return PARSE_IGNORE;
memcpy(state->auth.challenge_reply, tlv->nonce, BABEL_AUTH_NONCE_LEN);
state->auth.challenge_reply_seen = 1;
state->current_tlv_endpos += nonce_len;
return PARSE_SUCCESS;
}
static const struct babel_tlv_data challenge_reply_tlv_data = {
.min_length = sizeof(struct babel_tlv_challenge),
.read_tlv = &babel_read_challenge_reply,
};
static const struct babel_tlv_data *
get_auth_tlv_data(u8 type)
{
switch (type)
{
case BABEL_TLV_PC:
return &pc_tlv_data;
case BABEL_TLV_CHALLENGE_REQUEST:
return &challenge_req_tlv_data;
case BABEL_TLV_CHALLENGE_REPLY:
return &challenge_reply_tlv_data;
default:
return NULL;
}
}
uint
babel_auth_write_challenge(struct babel_tlv *hdr, union babel_msg *m,
struct babel_write_state *state UNUSED, uint max_len)
{
struct babel_tlv_challenge *tlv = (void *) hdr;
struct babel_msg_challenge *msg = &m->challenge;
uint len = sizeof(struct babel_tlv_challenge) + msg->nonce_len;
if (len > max_len)
return 0;
TLV_HDR(tlv, msg->type, len);
bmemcpy(tlv->nonce, msg->nonce, msg->nonce_len);
return len;
}
static void
babel_mac_fill(struct password_item *pass,
struct babel_mac_pseudoheader *phdr,
byte *pkt, uint pkt_len,
byte *mac)
{
struct mac_context ctx;
mac_init(&ctx, pass->alg, pass->password, pass->length);
mac_update(&ctx, (byte *)phdr, sizeof(*phdr));
mac_update(&ctx, (byte *)pkt, pkt_len);
memcpy(mac, mac_final(&ctx), mac_get_length(&ctx));
mac_cleanup(&ctx);
}
static void
babel_mac_build_phdr(struct babel_mac_pseudoheader *phdr,
ip_addr saddr, u16 sport,
ip_addr daddr, u16 dport)
{
memset(phdr, 0, sizeof(*phdr));
put_ip6(phdr->src_addr, saddr);
put_u16(&phdr->src_port, sport);
put_ip6(phdr->dst_addr, daddr);
put_u16(&phdr->dst_port, dport);
DBG("MAC pseudo-header: %I %d %I %d\n", saddr, sport, daddr, dport);
}
static int
babel_auth_check_mac(struct babel_iface *ifa, byte *pkt,
byte *trailer, uint trailer_len,
ip_addr saddr, u16 sport,
ip_addr daddr, u16 dport)
{
struct babel_proto *p = ifa->proto;
uint pkt_len = (uint)(trailer - pkt);
byte *end = trailer + trailer_len;
btime now_ = current_real_time();
if (trailer_len < sizeof(struct babel_tlv))
{
LOG_PKT_AUTH("Authentication failed for %I on %s - no MAC signature",
saddr, ifa->ifname);
return 0;
}
struct babel_mac_pseudoheader phdr;
babel_mac_build_phdr(&phdr, saddr, sport, daddr, dport);
struct password_item *pass;
WALK_LIST(pass, *ifa->cf->passwords)
{
byte mac[MAX_HASH_SIZE];
uint mac_len = mac_type_length(pass->alg);
uint frame_err = 0;
if (pass->accfrom > now_ || pass->accto < now_)
continue;
babel_mac_fill(pass, &phdr, pkt, pkt_len, mac);
struct babel_tlv *tlv0;
WALK_TLVS((void *)trailer, end, tlv0, frame_err, saddr, ifa->ifname)
{
struct babel_tlv_mac *tlv = (void *)tlv0;
if (tlv->type != BABEL_TLV_MAC)
continue;
if ((TLV_OPT_LENGTH(tlv) == mac_len) && !memcmp(tlv->mac, mac, mac_len))
return 1;
DBG("MAC mismatch key id %d pos %d len %d/%d\n",
pass->id, (int) ((byte *)tlv - (byte *)pkt), mac_len, tlv->length);
}
WALK_TLVS_END;
if (frame_err)
return 0;
}
LOG_PKT_AUTH("Authentication failed for %I on %s - no matching key",
saddr, ifa->ifname);
return 0;
}
/**
* babel_auth_check - Check authentication for a packet
* @ifa: Interface holding the transmission buffer
* @saddr: Source address the packet was received from
* @sport: Source port the packet was received from
* @daddr: Destination address the packet was sent to
* @dport: Destination port the packet was sent to
* @pkt: Pointer to start of the packet data
* @trailer: Pointer to the packet trailer
* @trailer_len: Length of the packet trailer
*
* This function performs any necessary authentication checks on a packet and
* returns 0 if the packet should be accepted (either because it has been
* successfully authenticated or because authentication is disabled or
* configured in permissive mode), or 1 if the packet should be dropped without
* further processing.
*/
int
babel_auth_check(struct babel_iface *ifa,
ip_addr saddr, u16 sport,
ip_addr daddr, u16 dport,
struct babel_pkt_header *pkt,
byte *trailer, uint trailer_len)
{
uint frame_err UNUSED = 0;
struct babel_proto *p = ifa->proto;
struct babel_tlv *tlv;
struct babel_parse_state state = {
.get_tlv_data = &get_auth_tlv_data,
.proto = p,
.ifa = ifa,
.saddr = saddr,
.is_unicast = !(ipa_classify(daddr) & IADDR_MULTICAST),
.auth = {
.sender = saddr,
},
};
if (ifa->cf->auth_type == BABEL_AUTH_NONE)
return 1;
TRACE(D_PACKETS, "Checking packet authentication signature");
if (!babel_auth_check_mac(ifa, (byte *)pkt,
trailer, trailer_len,
saddr, sport,
daddr, dport))
goto fail;
/* MAC verified; parse packet to check packet counter and challenge */
WALK_TLVS(FIRST_TLV(pkt), trailer, tlv, frame_err, saddr, ifa->ifname)
{
union babel_msg msg;
enum parse_result res;
res = babel_read_tlv(tlv, &msg, &state);
if (res == PARSE_ERROR)
{
LOG_PKT("Bad TLV from %I via %s type %d pos %d - parse error",
saddr, ifa->ifname, tlv->type, (int) ((byte *)tlv - (byte *)pkt));
goto fail;
}
}
WALK_TLVS_END;
if (!babel_auth_check_pc(ifa, &state.auth))
goto fail;
TRACE(D_PACKETS, "Packet from %I via %s authenticated successfully",
saddr, ifa->ifname);
return 1;
fail:
TRACE(D_PACKETS, "Packet from %I via %s failed authentication%s",
saddr, ifa->ifname,
ifa->cf->auth_permissive ? " but accepted in permissive mode" : "");
return ifa->cf->auth_permissive;
}
/**
* babel_auth_add_tlvs - Add authentication-related TLVs to a packet
* @ifa: Interface holding the transmission buffer
* @tlv: Pointer to the place where any new TLVs should be added
* @max_len: Maximum length available for adding new TLVs
*
* This function adds any new TLVs required by the authentication mode to a
* packet before it is shipped out. For MAC authentication, this is the packet
* counter TLV that must be included in every packet.
*/
int
babel_auth_add_tlvs(struct babel_iface *ifa, struct babel_tlv *hdr, uint max_len)
{
struct babel_proto *p = ifa->proto;
struct babel_tlv_pc *tlv;
uint len;
if (ifa->cf->auth_type == BABEL_AUTH_NONE)
return 0;
tlv = (void *) hdr;
len = sizeof(struct babel_tlv_pc) + BABEL_AUTH_INDEX_LEN;
max_len += ifa->auth_tx_overhead;
if (len > max_len)
{
LOG_WARN("Insufficient space to add MAC seqno TLV on iface %s: %d < %d",
ifa->ifname, max_len, len);
return 0;
}
TLV_HDR(tlv, BABEL_TLV_PC, len);
put_u32(&tlv->pc, ifa->auth_pc++);
memcpy(tlv->index, ifa->auth_index, BABEL_AUTH_INDEX_LEN);
/* Reset index on overflow to 0 */
if (!ifa->auth_pc)
babel_auth_reset_index(ifa);
return len;
}
/**
* babel_auth_sign - Sign an outgoing packet before transmission
* @ifa: Interface holding the transmission buffer
* @dest: Destination address of the packet
*
* This function adds authentication signature(s) to the packet trailer for each
* of the configured authentication keys on the interface.
*/
int
babel_auth_sign(struct babel_iface *ifa, ip_addr dest)
{
struct babel_proto *p = ifa->proto;
sock *sk = ifa->sk;
if (ifa->cf->auth_type == BABEL_AUTH_NONE)
return 0;
struct babel_pkt_header *hdr = (void *) sk->tbuf;
int len = get_u16(&hdr->length) + sizeof(struct babel_pkt_header);
byte *pkt = (byte *) hdr;
byte *pos = pkt + len;
byte *end = pkt + ifa->tx_length + ifa->auth_tx_overhead;
btime now_ = current_real_time();
struct babel_mac_pseudoheader phdr;
babel_mac_build_phdr(&phdr, sk->saddr, sk->sport, dest, sk->dport);
struct password_item *pass;
WALK_LIST(pass, *ifa->cf->passwords)
{
struct babel_tlv_mac *tlv = (void *) pos;
uint tlv_len = sizeof(struct babel_tlv_mac) + mac_type_length(pass->alg);
if (pass->genfrom > now_ || pass->gento < now_)
continue;
if (pos + tlv_len > end)
{
LOG_WARN("Insufficient space for MAC signatures on iface %s dst %I (%d/%d)",
ifa->ifname, dest, tlv_len, (int) (end-pos));
break;
}
TLV_HDR(tlv, BABEL_TLV_MAC, tlv_len);
babel_mac_fill(pass, &phdr, pkt, len, tlv->mac);
pos += tlv_len;
}
DBG("Added MAC signatures (%d bytes) on ifa %s for dest %I\n",
pos - (pkt + len), ifa->ifname, dest);
return pos - (pkt + len);
}
/**
* babel_auth_set_tx_overhead - Set interface TX overhead for authentication
* @ifa: Interface to configure
*
* This function sets the TX overhead for an interface based on its
* authentication configuration.
*/
void
babel_auth_set_tx_overhead(struct babel_iface *ifa)
{
if (ifa->cf->auth_type == BABEL_AUTH_NONE)
{
ifa->auth_tx_overhead = 0;
return;
}
ifa->auth_tx_overhead = (sizeof(struct babel_tlv_pc) + BABEL_AUTH_INDEX_LEN +
sizeof(struct babel_tlv_mac) * ifa->cf->mac_num_keys +
ifa->cf->mac_total_len);
ifa->tx_length -= ifa->auth_tx_overhead;
}
Reference in a new issue View git blame Copy permalink