bgp_message_builder.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#include "bgp/bgp_message_builder.h"
 
#include <vector>
 
#include "bgp/bgp_log.h"
#include "bgp/bgp_ribout.h"
#include "bgp/bgp_route.h"
#include "bgp/bgp_server.h"
#include "net/bgp_af.h"
#include "extended-community/tag.h"
#include "large-community/tag.h"
 
using std::unique_ptr;
 
BgpMessage::BgpMessage() : table_(NULL), datalen_(0) {
}
 
BgpMessage::~BgpMessage() {
}
 
bool BgpMessage::StartReach(const RibOut *ribout, const RibOutAttr *roattr,
                            const BgpRoute *route) {
    BgpProto::Update update;
    const BgpAttr *attr = roattr->attr();
    Address::Family family = table_->family();
 
    BgpAttrOrigin *origin = new BgpAttrOrigin(attr->origin());
    update.path_attributes.push_back(origin);
 
    if ((BgpAf::FamilyToAfi(family) == BgpAf::IPv4) &&
        (BgpAf::FamilyToSafi(family) == BgpAf::Unicast)) {
        BgpAttrNextHop *nh =
            new BgpAttrNextHop(attr->nexthop().to_v4().to_ulong());
        update.path_attributes.push_back(nh);
    }
 
    if (attr->med()) {
        BgpAttrMultiExitDisc *med = new BgpAttrMultiExitDisc(attr->med());
        update.path_attributes.push_back(med);
    }
 
    if (ribout->peer_type() == BgpProto::IBGP) {
        BgpAttrLocalPref *lp = new BgpAttrLocalPref(attr->local_pref());
        update.path_attributes.push_back(lp);
    }
 
    if (attr->atomic_aggregate()) {
        BgpAttrAtomicAggregate *aa = new BgpAttrAtomicAggregate;
        update.path_attributes.push_back(aa);
    }
 
    if (attr->aggregator_as_num()) {
        if (ribout->as4_supported()) {
            BgpAttr4ByteAggregator *agg = new BgpAttr4ByteAggregator(
                attr->aggregator_as_num(),
                attr->aggregator_adderess().to_v4().to_ulong());
            update.path_attributes.push_back(agg);
        } else {
            if (attr->aggregator_as_num() > 0xffff) {
                // For old neighbor, need to send AS4_Aggregator along with
                // AS_TRANS in regular aggregator attribute
                BgpAttrAggregator *agg = new BgpAttrAggregator(
                    AS_TRANS, attr->aggregator_adderess().to_v4().to_ulong());
                update.path_attributes.push_back(agg);
                BgpAttrAs4Aggregator *as4_agg = new BgpAttrAs4Aggregator(
                    attr->aggregator_as_num(),
                    attr->aggregator_adderess().to_v4().to_ulong());
                update.path_attributes.push_back(as4_agg);
            } else {
                BgpAttrAggregator *agg = new BgpAttrAggregator(
                    attr->aggregator_as_num(),
                    attr->aggregator_adderess().to_v4().to_ulong());
                update.path_attributes.push_back(agg);
            }
        }
    }
 
    if (!attr->originator_id().is_unspecified()) {
        BgpAttrOriginatorId *originator_id =
            new BgpAttrOriginatorId(attr->originator_id().to_ulong());
        update.path_attributes.push_back(originator_id);
    }
 
    if (attr->cluster_list()) {
        ClusterListSpec *clist =
            new ClusterListSpec(attr->cluster_list()->cluster_list());
        update.path_attributes.push_back(clist);
    }
 
 
    if (ribout->as4_supported()) {
        if (attr->aspath_4byte()) {
            AsPath4ByteSpec *path = new AsPath4ByteSpec(
                                attr->aspath_4byte()->path());
            update.path_attributes.push_back(path);
        }
    } else {
        if (attr->as_path()) {
            AsPathSpec *path = new AsPathSpec(attr->as_path()->path());
            update.path_attributes.push_back(path);
        }
        if (attr->as4_path()) {
            As4PathSpec *path = new As4PathSpec(attr->as4_path()->path());
            update.path_attributes.push_back(path);
        }
    }
 
    if (attr->edge_discovery()) {
        EdgeDiscoverySpec *edspec =
            new EdgeDiscoverySpec(attr->edge_discovery()->edge_discovery());
        update.path_attributes.push_back(edspec);
    }
 
    if (attr->edge_forwarding()) {
        EdgeForwardingSpec *efspec =
            new EdgeForwardingSpec(attr->edge_forwarding()->edge_forwarding());
        update.path_attributes.push_back(efspec);
    }
 
    if (attr->community() && attr->community()->communities().size()) {
        CommunitySpec *comm = new CommunitySpec;
        comm->communities = attr->community()->communities();
        update.path_attributes.push_back(comm);
    }
 
    ExtCommunitySpec *ext_comm = new ExtCommunitySpec;
    if (attr->ext_community() && attr->ext_community()->communities().size()) {
        const ExtCommunity::ExtCommunityList &v =
                attr->ext_community()->communities();
        for (ExtCommunity::ExtCommunityList::const_iterator it = v.begin();
                it != v.end(); ++it) {
            uint64_t value = get_value(it->data(), it->size());
            ext_comm->communities.push_back(value);
        }
    }
 
    LargeCommunitySpec *large_comm = new LargeCommunitySpec;
    if (attr->large_community() && attr->large_community()->communities().size()) {
        uint16_t tag_index = 0;
        const LargeCommunity::LargeCommunityList &v =
                attr->large_community()->communities();
        uint64_t tid64;
        uint32_t asn, tid, value;
        for (LargeCommunity::LargeCommunityList::const_iterator it = v.begin();
             it != v.end(); ++it) {
                TagLC tag_lc {*it};
                tid64 = tag_lc.tag();
                if ((tid64 & 0xFFFF0000) == 0) {
                    asn = tag_lc.as_number();
                    tid = ((tid64 & 0xFFFF00000000) >> 16) |
                        (tid64 & 0xFFFF);
                    if (asn <= AS2_MAX) {
                        Tag tag {as2_t(asn), tid};
                        ext_comm->communities.push_back(tag.GetExtCommunityValue());
                    } else {
                        Tag4ByteAs tag4 {asn, tag_index};
                        Tag tag {tag_index, tid};
                        ext_comm->communities.push_back(tag.GetExtCommunityValue());
                        ext_comm->communities.push_back(tag4.GetExtCommunityValue());
                        tag_index++;
                    }
                    continue;
                }
 
                for (int i = 0; i < 3; i++) {
                    value = get_value(it->data() + 4*i, 4);
                    large_comm->communities.push_back(value);
                }
        }
        update.path_attributes.push_back(large_comm);
    }
    if (ext_comm->EncodeLength()) {
        update.path_attributes.push_back(ext_comm);
    }
 
    if (attr->origin_vn_path() && attr->origin_vn_path()->origin_vns().size()) {
        OriginVnPathSpec *ovnpath_spec = new OriginVnPathSpec;
        const OriginVnPath::OriginVnList &v =
            attr->origin_vn_path()->origin_vns();
        for (OriginVnPath::OriginVnList::const_iterator it = v.begin();
             it != v.end(); ++it) {
            uint64_t value = get_value(it->data(), it->size());
            ovnpath_spec->origin_vns.push_back(value);
        }
        update.path_attributes.push_back(ovnpath_spec);
    }
 
    if (attr->pmsi_tunnel()) {
        PmsiTunnelSpec *pmsi_spec =
            new PmsiTunnelSpec(attr->pmsi_tunnel()->pmsi_tunnel());
        update.path_attributes.push_back(pmsi_spec);
    }
 
    std::vector<uint8_t> nh;
 
    route->BuildBgpProtoNextHop(nh, attr->nexthop());
 
    BgpMpNlri *nlri = new BgpMpNlri(
        BgpAttribute::MPReachNlri, BgpAf::FamilyToAfi(family),
        BgpAf::FamilyToSafi(family), nh);
    update.path_attributes.push_back(nlri);
 
    BgpProtoPrefix *prefix = new BgpProtoPrefix;
    const uint32_t label = (family == Address::INET) ? 0 : roattr->label();
    route->BuildProtoPrefix(prefix, attr, label, roattr->l3_label());
    nlri->nlri.push_back(prefix);
 
    int result = BgpProto::Encode(&update, data_, sizeof(data_),
                                  &encode_offsets_, ribout->as4_supported());
    if (result <= 0) {
        BGP_LOG_WARNING_STR(BgpMessageSend, BGP_LOG_FLAG_ALL,
            "Error encoding reach message for route " << route->ToString() <<
            " in table " << (table_ ? table_->name() : "unknown"));
        table_->server()->increment_message_build_error();
        return false;
    }
 
    num_reach_route_++;
    datalen_ = result;
    return true;
}
 
bool BgpMessage::StartUnreach(const BgpRoute *route) {
    BgpProto::Update update;
    Address::Family family = table_->family();
 
    BgpMpNlri *nlri =
        new BgpMpNlri(BgpAttribute::MPUnreachNlri,
        BgpAf::FamilyToAfi(family), BgpAf::FamilyToSafi(family));
    update.path_attributes.push_back(nlri);
 
    BgpProtoPrefix *prefix = new BgpProtoPrefix;
    route->BuildProtoPrefix(prefix);
    nlri->nlri.push_back(prefix);
 
    int result =
        BgpProto::Encode(&update, data_, sizeof(data_), &encode_offsets_);
    if (result <= 0) {
        BGP_LOG_WARNING_STR(BgpMessageSend, BGP_LOG_FLAG_ALL,
            "Error encoding unreach message for route " << route->ToString() <<
            " in table " << (table_ ? table_->name() : "unknown"));
        table_->server()->increment_message_build_error();
        return false;
    }
 
    num_unreach_route_++;
    datalen_ = result;
    return true;
}
 
void BgpMessage::Reset() {
    Message::Reset();
    table_ = NULL;
    encode_offsets_.ClearOffsets();
    datalen_ = 0;
}
 
bool BgpMessage::Start(const RibOut *ribout, bool cache_repr,
    const RibOutAttr *roattr, const BgpRoute *route) {
    Reset();
    table_ = ribout->table();
 
    if (roattr->IsReachable()) {
        return StartReach(ribout, roattr, route);
    } else {
        return StartUnreach(route);
    }
}
 
bool BgpMessage::UpdateLength(const char *tag, int size, int delta) {
    int offset = encode_offsets_.FindOffset(tag);
    if (offset < 0) {
        return false;
    }
    int value = get_value(&data_[offset], size);
    value += delta;
    put_value(&data_[offset], size, value);
    return true;
}
 
bool BgpMessage::AddRoute(const BgpRoute *route, const RibOutAttr *roattr) {
    uint8_t *data = data_ + datalen_;
    size_t size = sizeof(data_) - datalen_;
    Address::Family family = table_->family();
 
    BgpMpNlri nlri;
    nlri.afi = BgpAf::FamilyToAfi(family);
    nlri.safi = BgpAf::FamilyToSafi(family);
    BgpProtoPrefix *prefix = new BgpProtoPrefix;
    if (roattr) {
        const uint32_t label = (family == Address::INET) ? 0 : roattr->label();
        route->BuildProtoPrefix(prefix, roattr->attr(), label);
    } else {
        route->BuildProtoPrefix(prefix);
    }
    nlri.nlri.push_back(prefix);
 
    int result = BgpProto::Encode(&nlri, data, size);
    if (result <= 0) {
        return false;
    }
 
    datalen_ += result;
    if (roattr->IsReachable()) {
        num_reach_route_++;
    } else {
        num_unreach_route_++;
    }
 
    if (!UpdateLength("BgpMsgLength", 2, result)) {
        assert(false);
        return false;
    }
 
    if (!UpdateLength("BgpPathAttribute", 2, result)) {
        assert(false);
        return false;
    }
 
    if (!UpdateLength("MpReachUnreachNlri", 2, result)) {
        assert(false);
        return false;
    }
 
    return true;
}
 
void BgpMessage::Finish() {
}
 
const uint8_t *BgpMessage::GetData(IPeerUpdate *peer, size_t *lenp,
    const string **msg_str, string *temp) {
    *lenp = datalen_;
    return data_;
}
 
Message *BgpMessageBuilder::Create() const {
    return new BgpMessage;
}
 
BgpMessageBuilder::BgpMessageBuilder()
: MessageBuilder() {
}