bgp-filter.cc

Go to the documentation of this file.

#include <arpa/inet.h>
#include "bgp-filter.h"
#include "value-op.h"

namespace libbgp {

BgpFilterRule::~BgpFilterRule() {}

BgpFilterRuleRoute4::BgpFilterRuleRoute4(BgpFilterOP op, BgpFilterRuleRouteMatchType type, const Prefix4 &prefix) {
    this->op = op;
    this->match_type = type;
    this->prefix = prefix;
}

BgpFilterRuleRoute6::BgpFilterRuleRoute6(BgpFilterOP op, BgpFilterRuleRouteMatchType type, const Prefix6 &prefix) {
    this->op = op;
    this->match_type = type;
    this->prefix = prefix;
}

BgpFilterRuleAsPath::BgpFilterRuleAsPath(BgpFilterOP op, BgpFilterRuleAsPathMatchType type, uint32_t asn) {
    this->op = op;
    this->match_type = type;
    this->asn = asn;
}

BgpFilterOP BgpFilterRuleAsPath::apply(__attribute__((unused)) const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs) {
    for (const std::shared_ptr<BgpPathAttrib> &attr : attribs) {
        if (attr->type_code != AS_PATH) continue;
        const BgpPathAttribAsPath &as_path = dynamic_cast<const BgpPathAttribAsPath &>(*attr);

        for (const BgpAsPathSegment &as_seg : as_path.as_paths) {
            if (as_seg.type != AS_SEQUENCE) continue;

            if (match_type == M_FROM_ASN && asn == as_seg.value.back()) return op;
            if (match_type == M_NOT_FROM_ASN && asn != as_seg.value.back()) return op;

            for (uint32_t asn : as_seg.value) {
                if (asn == this->asn && match_type == M_HAS_ASN) return op;
            }

        }

        if (match_type == M_NOT_HAS_ASN) return op; 
    }

    return NOP;
}

BgpFilterRuleCommunity::BgpFilterRuleCommunity(BgpFilterOP op, BgpFilterRuleCommunityMatchType type, uint16_t asn, uint16_t keyword) {
    this->op = op;
    this->match_type = type;
    uint8_t *community_ptr = (uint8_t *) &community;
    putValue<uint16_t>(&community_ptr, htons(asn));
    putValue<uint16_t>(&community_ptr, htons(keyword));
}

BgpFilterRuleCommunity::BgpFilterRuleCommunity(BgpFilterOP op, BgpFilterRuleCommunityMatchType type, uint32_t community) {
    this->op = op;
    this->match_type = type;
    this->community = htonl(community);
}

BgpFilterOP BgpFilterRuleCommunity::apply(__attribute__((unused)) const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs) {
    for (const std::shared_ptr<BgpPathAttrib> &attr : attribs) {
        if (attr->type_code != COMMUNITY) continue;
        const BgpPathAttribCommunity &community = dynamic_cast<const BgpPathAttribCommunity &>(*attr);

        for (uint32_t community_val : community.communites) {
            if (match_type == M_HAS_COMMUNITY && community_val == this->community) return op;
        }

        if (match_type == M_NOT_HAS_COMMUNITY) return op;
    }

    return NOP;
}

BgpFilterRules::BgpFilterRules() {
    default_op = ACCEPT;
}

BgpFilterRules::BgpFilterRules(BgpFilterOP default_op) {
    this->default_op = default_op;
}

BgpFilterOP BgpFilterRules::apply(const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs) {
    if (rules.size() == 0) return default_op;
    
    auto rule = rules.end();

    do {
        rule--;
        BgpFilterOP this_op = (*rule)->apply(prefix, attribs);
        if (this_op != NOP) return this_op;
    } while (rule != rules.begin());

    return default_op;
}

}