X-Git-Url: http://git.sameswireless.fr/l2tpns.git/blobdiff_plain/f4fb6922fee52973e2f568f18411594c88b40aa2..e6fe57eec8fc00543e7ee5f4e137331a6c65217c:/bgp.c diff --git a/bgp.c b/bgp.c index 1e1713d..7ac4c12 100644 --- a/bgp.c +++ b/bgp.c @@ -49,8 +49,6 @@ static int bgp_send_update(struct bgp_peer *peer); static int bgp_send_update6(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; @@ -250,6 +248,53 @@ int bgp_start(struct bgp_peer *peer, char *name, int as, int keepalive, memcpy(peer->path_attrs, path_attrs, peer->path_attr_len); + /* multiprotocol attributes initialization */ + if (config->ipv6_prefix.s6_addr[0]) + { + struct bgp_attr_mp_reach_nlri_partial mp_reach_nlri_partial; + struct bgp_attr_mp_unreach_nlri_partial mp_unreach_nlri_partial; + + a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL; + a.code = BGP_PATH_ATTR_CODE_MP_REACH_NLRI; + a.data.s.len = 0; /* will be set on UPDATE */ + + mp_reach_nlri_partial.afi = htons(BGP_MP_AFI_IPv6); + mp_reach_nlri_partial.safi = BGP_MP_SAFI_UNICAST; + mp_reach_nlri_partial.reserved = 0; + mp_reach_nlri_partial.next_hop_len = 16; + + /* use the defined nexthop6, or our address in ipv6_prefix */ + if (config->nexthop6_address.s6_addr[0]) + memcpy(&mp_reach_nlri_partial.next_hop, + &config->nexthop6_address.s6_addr, 16); + else + { + /* our address is ipv6prefix::1 */ + memcpy(&mp_reach_nlri_partial.next_hop, + &config->ipv6_prefix.s6_addr, 16); + mp_reach_nlri_partial.next_hop[15] = 1; + } + + memcpy(&a.data.s.value, &mp_reach_nlri_partial, + sizeof(struct bgp_attr_mp_reach_nlri_partial)); + memcpy(&peer->mp_reach_nlri_partial, &a, + BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE); + + a.flags = BGP_PATH_ATTR_FLAG_OPTIONAL | BGP_PATH_ATTR_FLAG_EXTLEN; + a.code = BGP_PATH_ATTR_CODE_MP_UNREACH_NLRI; + a.data.e.len = 0; /* will be set on UPDATE */ + + mp_unreach_nlri_partial.afi = htons(BGP_MP_AFI_IPv6); + mp_unreach_nlri_partial.safi = BGP_MP_SAFI_UNICAST; + + memcpy(&a.data.e.value, &mp_unreach_nlri_partial, + sizeof(struct bgp_attr_mp_unreach_nlri_partial)); + memcpy(&peer->mp_unreach_nlri_partial, &a, + BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE); + } + + peer->mp_handling = HandlingUnknown; + LOG(4, 0, 0, "Initiating BGP connection to %s (routing %s)\n", name, enable ? "enabled" : "suspended"); @@ -509,7 +554,8 @@ int bgp_add_route6(struct in6_addr ip, int prefixlen) /* flag established peers for update */ for (i = 0; i < BGP_NUM_PEERS; i++) - if (bgp_peers[i].state == Established) + if (bgp_peers[i].state == Established + && bgp_peers[i].mp_handling == HandleIPv6Routes) bgp_peers[i].update_routes6 = 1; LOG(4, 0, 0, "Registered BGP route %s/%d\n", @@ -609,7 +655,8 @@ int bgp_del_route6(struct in6_addr ip, int prefixlen) /* flag established peers for update */ for (i = 0; i < BGP_NUM_PEERS; i++) - if (bgp_peers[i].state == Established) + if (bgp_peers[i].state == Established + && bgp_peers[i].mp_handling == HandleIPv6Routes) bgp_peers[i].update_routes6 = 1; LOG(4, 0, 0, "Removed BGP route %s/%d\n", @@ -922,8 +969,6 @@ 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); } @@ -947,8 +992,6 @@ 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); } @@ -1142,7 +1185,7 @@ static int bgp_handle_input(struct bgp_peer *peer) param_offset < data.opt_len; param_offset += 2 + param->len) { - param = (struct bgp_opt_param *)(&data.opt_params + param_offset); + param = (struct bgp_opt_param *)((char *)&data.opt_params + param_offset); /* sensible check */ if (data.opt_len - param_offset < 2 @@ -1167,11 +1210,8 @@ static int bgp_handle_input(struct bgp_peer *peer) capabilities_len = param->len; capabilities = (char *)¶m->value; - } - /* look for BGP multiprotocol capability */ - if (capabilities) - { + /* look for BGP multiprotocol capability */ for (capability_offset = 0; capability_offset < capabilities_len; capability_offset += 2 + capability->len) @@ -1196,29 +1236,34 @@ static int bgp_handle_input(struct bgp_peer *peer) 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) + if (ntohs(mp_cap->afi) != BGP_MP_AFI_IPv6 && 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; + /* yes it can! */ + peer->mp_handling = HandleIPv6Routes; } } + if (peer->mp_handling != HandleIPv6Routes) + { + peer->mp_handling = DoesntHandleIPv6Routes; + if (config->ipv6_prefix.s6_addr[0]) + LOG(1, 0, 0, "Warning: BGP peer %s doesn't handle IPv6 prefixes updates\n", + peer->name); + } + /* next transition requires an exchange of keepalives */ bgp_send_keepalive(peer); } @@ -1253,6 +1298,15 @@ 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_PARAM) + { + LOG(4, 0, 0, "BGP peer %s doesn't support BGP Capabilities\n", peer->name); + peer->mp_handling = DoesntHandleIPv6Routes; + bgp_restart(peer); + return 0; + } + if (notification->error_code == BGP_ERR_OPEN && notification->error_subcode == BGP_ERR_OPN_UNSUP_CAP) { @@ -1260,7 +1314,7 @@ static int bgp_handle_input(struct bgp_peer *peer) 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; + peer->mp_handling = DoesntHandleIPv6Routes; break; } @@ -1294,7 +1348,7 @@ 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_mp_cap_param mp_ipv6 = { htons(BGP_MP_AFI_IPv6), 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); @@ -1309,20 +1363,29 @@ static int bgp_send_open(struct bgp_peer *peer) data.hold_time = htons(peer->hold); data.identifier = my_address; - /* 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); + /* if we know peer doesn't support MP (mp_handling == DoesntHandleIPv6Routes) + then don't add this parameter */ + if (config->ipv6_prefix.s6_addr[0] + && (peer->mp_handling == HandlingUnknown + || peer->mp_handling == HandleIPv6Routes)) + { + /* 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); + 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); + data.opt_len = 2 + param_cap_mp_ipv6.len; + memcpy(&data.opt_params, ¶m_cap_mp_ipv6, data.opt_len); + } + else + data.opt_len = 0; - memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE); - len += BGP_DATA_OPEN_SIZE; + memcpy(peer->outbuf->packet.data, &data, BGP_DATA_OPEN_SIZE + data.opt_len); + len += BGP_DATA_OPEN_SIZE + data.opt_len; peer->outbuf->packet.header.len = htons(len); peer->outbuf->done = 0; @@ -1492,17 +1555,176 @@ static int bgp_send_update(struct bgp_peer *peer) /* send/buffer UPDATE message for IPv6 routes */ static int bgp_send_update6(struct bgp_peer *peer) { + uint16_t attr_len; + uint16_t unreach_len = 0; + char *unreach_len_pos; + uint8_t reach_len; + uint16_t len = sizeof(peer->outbuf->packet.header); + struct bgp_route6_list *have = peer->routes6; + struct bgp_route6_list *want = peer->routing ? bgp_routes6 : 0; + struct bgp_route6_list *e = 0; + struct bgp_route6_list *add = 0; + int s; + char ipv6addr[INET6_ADDRSTRLEN]; + + char *data = (char *) &peer->outbuf->packet.data; + + /* need leave room for attr_len, bgp_path_attrs and one prefix */ + char *max = (char *) &peer->outbuf->packet.data + + sizeof(peer->outbuf->packet.data) + - sizeof(attr_len) - peer->path_attr_len_without_nexthop + - BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE - sizeof(struct bgp_ip6_prefix); + + memset(peer->outbuf->packet.header.marker, 0xff, + sizeof(peer->outbuf->packet.header.marker)); + + peer->outbuf->packet.header.type = BGP_MSG_UPDATE; + + /* insert non-MP unfeasible routes length */ + memcpy(data, &unreach_len, sizeof(unreach_len)); + /* skip over it and attr_len too; it will be filled when known */ + data += sizeof(unreach_len) + sizeof(attr_len); + len += sizeof(unreach_len) + sizeof(attr_len); + + /* copy usual attributes */ + memcpy(data, peer->path_attrs, peer->path_attr_len_without_nexthop); + data += peer->path_attr_len_without_nexthop; + len += peer->path_attr_len_without_nexthop; + + /* copy MP unreachable NLRI heading */ + memcpy(data, peer->mp_unreach_nlri_partial, + BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE); + /* remember where to update this attr len */ + unreach_len_pos = data + 2; + data += BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE; + len += BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE; + + peer->update_routes6 = 0; /* tentatively clear */ + + /* find differences */ + while ((have || want) && data < (max - sizeof(struct bgp_ip6_prefix))) + { + if (have) + s = want + ? memcmp(&have->dest, &want->dest, sizeof(have->dest)) + : -1; + else + s = 1; + + if (s < 0) /* found one to delete */ + { + struct bgp_route6_list *tmp = have; + have = have->next; + + s = BGP_IP_PREFIX_SIZE(tmp->dest); + memcpy(data, &tmp->dest, s); + data += s; + unreach_len += s; + len += s; + + LOG(5, 0, 0, "Withdrawing route %s/%d from BGP peer %s\n", + inet_ntop(AF_INET6, &tmp->dest.prefix, ipv6addr, INET6_ADDRSTRLEN), + tmp->dest.len, peer->name); + + free(tmp); + + if (e) + e->next = have; + else + peer->routes6 = have; + } + else + { + if (!s) /* same */ + { + e = have; /* stash the last found to relink above */ + have = have->next; + want = want->next; + } + else if (s > 0) /* addition reqd. */ + { + if (add) + { + peer->update_routes6 = 1; /* only one add per packet */ + if (!have) + break; + } + else + add = want; + + if (want) + want = want->next; + } + } + } + + if (have || want) + peer->update_routes6 = 1; /* more to do */ + + /* anything changed? */ + if (!(unreach_len || add)) + return 1; + + if (unreach_len) + { + /* go back and insert MP unreach_len */ + unreach_len += sizeof(struct bgp_attr_mp_unreach_nlri_partial); + unreach_len = htons(unreach_len); + memcpy(unreach_len_pos, &unreach_len, sizeof(unreach_len)); + } + else + { + /* we can remove this attribute, then */ + data -= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE; + len -= BGP_PATH_ATTR_MP_UNREACH_NLRI_PARTIAL_SIZE; + } + + if (add) + { + if (!(e = malloc(sizeof(*e)))) + { + LOG(0, 0, 0, "Can't allocate route for %s/%d (%s)\n", + inet_ntop(AF_INET6, &add->dest.prefix, ipv6addr, INET6_ADDRSTRLEN), + add->dest.len, strerror(errno)); + + return 0; + } + + memcpy(e, add, sizeof(*e)); + e->next = 0; + peer->routes6 = bgp_insert_route6(peer->routes6, e); + + /* copy MP reachable NLRI heading */ + memcpy(data, peer->mp_reach_nlri_partial, + BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE); + /* with proper len */ + reach_len = BGP_IP_PREFIX_SIZE(add->dest); + data[2] = sizeof(struct bgp_attr_mp_reach_nlri_partial) + reach_len; + data += BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE; + len += BGP_PATH_ATTR_MP_REACH_NLRI_PARTIAL_SIZE; + + memcpy(data, &add->dest, reach_len); + data += reach_len; + len += reach_len; + + LOG(5, 0, 0, "Advertising route %s/%d to BGP peer %s\n", + inet_ntop(AF_INET6, &add->dest.prefix, ipv6addr, INET6_ADDRSTRLEN), + add->dest.len, peer->name); + } + + /* go back and insert attr_len */ + attr_len = htons(len - 4); + memcpy((char *)&peer->outbuf->packet.data + 2, &attr_len, sizeof(attr_len)); + + peer->outbuf->packet.header.len = htons(len); + peer->outbuf->done = 0; + + return bgp_write(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; @@ -1513,9 +1735,6 @@ static int bgp_send_notification_full(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));