X-Git-Url: http://git.sameswireless.fr/l2tpns.git/blobdiff_plain/a4bf68528c6f8e4f4290941afa9ebfb193ce153b..f2e59e98817d4959af549abccf4e798e6184f6d4:/bgp.c?ds=sidebyside diff --git a/bgp.c b/bgp.c index 6a868fa..f12efb1 100644 --- a/bgp.c +++ b/bgp.c @@ -45,6 +45,8 @@ static int bgp_send_keepalive(struct bgp_peer *peer); static int bgp_send_update(struct bgp_peer *peer); static int bgp_send_notification(struct bgp_peer *peer, uint8_t code, uint8_t subcode); +static int bgp_send_notification_full(struct bgp_peer *peer, uint8_t code, + uint8_t subcode, char *notification_data, uint16_t data_len); static uint16_t our_as; static struct bgp_route_list *bgp_routes = 0; @@ -760,6 +762,8 @@ static int bgp_connect(struct bgp_peer *peer) LOG(4, 0, 0, "BGP peer %s: state Active\n", inet_ntoa(addr.sin_addr)); + peer->handle_ipv6_routes = 0; + return bgp_send_open(peer); } @@ -783,6 +787,8 @@ static int bgp_handle_connect(struct bgp_peer *peer) LOG(4, 0, 0, "BGP peer %s: state Active\n", peer->name); + peer->handle_ipv6_routes = 0; + return bgp_send_open(peer); } @@ -902,6 +908,12 @@ static int bgp_handle_input(struct bgp_peer *peer) struct bgp_data_open data; int hold; int i; + off_t param_offset, capability_offset; + struct bgp_opt_param *param; + uint8_t capabilities_len; + char *capabilities = NULL; + struct bgp_capability *capability; + struct bgp_mp_cap_param *mp_cap; for (i = 0; i < sizeof(p->header.marker); i++) { @@ -964,10 +976,91 @@ static int bgp_handle_input(struct bgp_peer *peer) if (peer->keepalive * 3 > peer->hold) peer->keepalive = peer->hold / 3; + /* check for optional parameters */ + /* 2 is for the size of type + len (both uint8_t) */ + for (param_offset = 0; + param_offset < data.opt_len; + param_offset += 2 + param->len) + { + param = (struct bgp_opt_param *)(&data.opt_params + param_offset); + + /* sensible check */ + if (data.opt_len - param_offset < 2 + || param->len > data.opt_len - param_offset - 2) + { + LOG(1, 0, 0, "Malformed Optional Parameter list from BGP peer %s\n", + peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_UNSPEC); + return 0; + } + + /* we know only one parameter type */ + if (param->type != BGP_PARAM_TYPE_CAPABILITY) + { + LOG(1, 0, 0, "Unsupported Optional Parameter type %d from BGP peer %s\n", + param->type, peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_PARAM); + return 0; + } + + capabilities_len = param->len; + capabilities = (char *)¶m->value; + } + + /* look for BGP multiprotocol capability */ + if (capabilities) + { + for (capability_offset = 0; + capability_offset < capabilities_len; + capability_offset += 2 + capability->len) + { + capability = (struct bgp_capability *)(capabilities + capability_offset); + + /* sensible check */ + if (capabilities_len - capability_offset < 2 + || capability->len > capabilities_len - capability_offset - 2) + { + LOG(1, 0, 0, "Malformed Capabilities list from BGP peer %s\n", + peer->name); + + bgp_send_notification(peer, BGP_ERR_OPEN, BGP_ERR_UNSPEC); + return 0; + } + + /* we only know one capability code */ + if (capability->code != BGP_CAP_CODE_MP + && capability->len != sizeof(struct bgp_mp_cap_param)) + { + LOG(4, 0, 0, "Unsupported Capability code %d from BGP peer %s\n", + capability->code, peer->name); + + bgp_send_notification_full(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_CAP, + (char *)capability, 2 + capability->len); + /* we don't terminate, still; we just jump to the next one */ + continue; + } + + mp_cap = (struct bgp_mp_cap_param *)&capability->value; + /* the only tuple we support */ + if (ntohs(mp_cap->afi) != AF_INET6 && mp_cap->safi != BGP_MP_SAFI_UNICAST) + { + LOG(4, 0, 0, "Unsupported multiprotocol AFI %d and SAFI %d from BGP peer %s\n", + mp_cap->afi, mp_cap->safi, peer->name); + + bgp_send_notification_full(peer, BGP_ERR_OPEN, BGP_ERR_OPN_UNSUP_CAP, + (char *)capability, 2 + capability->len); + /* we don't terminate, still; we just jump to the next one */ + continue; + } + + peer->handle_ipv6_routes = 1; + } + } + /* next transition requires an exchange of keepalives */ bgp_send_keepalive(peer); - - /* FIXME: may need to check for optional params */ } break; @@ -1000,6 +1093,17 @@ static int bgp_handle_input(struct bgp_peer *peer) return 0; } + if (notification->error_code == BGP_ERR_OPEN + && notification->error_subcode == BGP_ERR_OPN_UNSUP_CAP) + { + /* the only capability we advertise is this one, so upon receiving + an "unsupported capability" message, we disable IPv6 routes for + this peer */ + LOG(4, 0, 0, "BGP peer %s doesn't support IPv6 routes advertisement\n", peer->name); + peer->handle_ipv6_routes = 0; + break; + } + /* FIXME: should handle more notifications */ LOG(4, 0, 0, "BGP peer %s sent unhandled NOTIFICATION %d\n", peer->name, (int) notification->error_code); @@ -1030,6 +1134,9 @@ static int bgp_handle_input(struct bgp_peer *peer) static int bgp_send_open(struct bgp_peer *peer) { struct bgp_data_open data; + struct bgp_mp_cap_param mp_ipv6 = { htons(AF_INET6), 0, BGP_MP_SAFI_UNICAST }; + struct bgp_capability cap_mp_ipv6; + struct bgp_opt_param param_cap_mp_ipv6; uint16_t len = sizeof(peer->outbuf->packet.header); memset(peer->outbuf->packet.header.marker, 0xff, @@ -1041,7 +1148,18 @@ static int bgp_send_open(struct bgp_peer *peer) data.as = htons(our_as); data.hold_time = htons(peer->hold); data.identifier = my_address; - data.opt_len = 0; + + /* construct the param and capability */ + cap_mp_ipv6.code = BGP_CAP_CODE_MP; + cap_mp_ipv6.len = sizeof(mp_ipv6); + memcpy(&cap_mp_ipv6.value, &mp_ipv6, cap_mp_ipv6.len); + + param_cap_mp_ipv6.type = BGP_PARAM_TYPE_CAPABILITY; + param_cap_mp_ipv6.len = 2 + sizeof(mp_ipv6); + memcpy(¶m_cap_mp_ipv6.value, &cap_mp_ipv6, param_cap_mp_ipv6.len); + + data.opt_len = 2 + param_cap_mp_ipv6.len; + memcpy(&data.opt_params, ¶m_cap_mp_ipv6, data.opt_len); memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE); len += BGP_DATA_OPEN_SIZE; @@ -1214,6 +1332,12 @@ static int bgp_send_update(struct bgp_peer *peer) /* send/buffer NOTIFICATION message */ static int bgp_send_notification(struct bgp_peer *peer, uint8_t code, uint8_t subcode) +{ + return bgp_send_notification_full(peer, code, subcode, NULL, 0); +} + +static int bgp_send_notification_full(struct bgp_peer *peer, uint8_t code, + uint8_t subcode, char *notification_data, uint16_t data_len) { struct bgp_data_notification data; uint16_t len = 0; @@ -1224,6 +1348,9 @@ static int bgp_send_notification(struct bgp_peer *peer, uint8_t code, data.error_subcode = subcode; len += sizeof(data.error_code); + memcpy(data.data, notification_data, data_len); + len += data_len; + memset(peer->outbuf->packet.header.marker, 0xff, sizeof(peer->outbuf->packet.header.marker));