bgp-filter.h

Go to the documentation of this file.

#ifndef BGP_FILTER_H_
#define BGP_FILTER_H_
#include <vector>
#include <memory>
#include "bgp-afi.h"
#include "prefix4.h"
#include "prefix6.h"
#include "bgp-path-attrib.h"

namespace libbgp {

enum BgpFilterRuleType {
    F_ROUTE, 
    F_AS_PATH, 
    F_COMMUNITY 
};

enum BgpFilterRuleRouteMatchType {
    M_EQ, 
    M_NE, 
    M_GT, 
    M_LT, 
    M_GE, 
    M_LE 
};

enum BgpFilterRuleAsPathMatchType {
    M_HAS_ASN, 
    M_NOT_HAS_ASN, 
    M_FROM_ASN, 
    M_NOT_FROM_ASN 
};

enum BgpFilterRuleCommunityMatchType {
    M_HAS_COMMUNITY, 
    M_NOT_HAS_COMMUNITY 
};

enum BgpFilterOP {
    NOP, 
    ACCEPT, 
    REJECT 
};

class BgpFilterRule {
public:
    uint8_t filter_type;
    uint8_t match_type;
    BgpFilterOP op;

    virtual BgpFilterOP apply(const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs) = 0;
    virtual ~BgpFilterRule();
};

template <typename T>
class BgpFilterRuleRoute : public BgpFilterRule {
public:
    BgpFilterRuleRoute() {
        filter_type = F_ROUTE;
    }

    T prefix;

    BgpFilterOP apply(const Prefix &prefix, __attribute__((unused)) const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs) {
        if (prefix.afi != this->prefix.afi) return NOP;
        const T &prefix_t = dynamic_cast<const T &>(prefix);
        switch (match_type) {
            case M_EQ: return prefix_t == this->prefix ? op : NOP;
            case M_NE: return prefix_t != this->prefix ? op : NOP;
            case M_GT: return prefix_t != this->prefix && prefix_t.includes(this->prefix) ? op : NOP;
            case M_LT: return prefix_t != this->prefix && this->prefix.includes(prefix_t) ? op : NOP;
            case M_GE: return prefix_t.includes(this->prefix) ? op : NOP;
            case M_LE: return this->prefix.includes(prefix_t) ? op : NOP;
        }

        return NOP;
    }

    virtual ~BgpFilterRuleRoute() {}
};
#ifdef SWIG
%template(Prefix4RouteFilterRule) BgpFilterRuleRoute<Prefix4>;
%template(Prefix6RouteFilterRule) BgpFilterRuleRoute<Prefix6>;
#endif

class BgpFilterRuleRoute4 : public BgpFilterRuleRoute<Prefix4> {
public:
    BgpFilterRuleRoute4(BgpFilterOP op, BgpFilterRuleRouteMatchType type, const Prefix4 &prefix);
};

class BgpFilterRuleRoute6 : public BgpFilterRuleRoute<Prefix6> {
public:
    BgpFilterRuleRoute6(BgpFilterOP op, BgpFilterRuleRouteMatchType type, const Prefix6 &prefix);
};

class BgpFilterRuleAsPath : public BgpFilterRule {
public:
    BgpFilterRuleAsPath(BgpFilterOP op, BgpFilterRuleAsPathMatchType type, uint32_t asn);

    uint32_t asn;

    BgpFilterOP apply(const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs);
};

enum BgpWellKnownCommunity {
    NO_EXPORT = 0xFFFFFF01,
    NO_ADVERTISE = 0xFFFFFF02,
    NO_EXPORT_SUBCONFED = 0xFFFFFF03
};

class BgpFilterRuleCommunity : public BgpFilterRule {
public:
    BgpFilterRuleCommunity(BgpFilterOP op, BgpFilterRuleCommunityMatchType type, uint16_t asn, uint16_t keyword);
    BgpFilterRuleCommunity(BgpFilterOP op, BgpFilterRuleCommunityMatchType type, uint32_t community);

    uint32_t community;

    BgpFilterOP apply(const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs);
};

class BgpFilterRules {
public:

    BgpFilterRules();
    BgpFilterRules(BgpFilterOP default_op);

    template <typename T>
    void append(const BgpFilterRule &rule) {
        const T &rule_typed = dynamic_cast<const T&> (rule);
        rules.push_back(std::shared_ptr<BgpFilterRule>(new T(rule_typed)));
    }
#ifdef SWIG
%template(appendAsPathRule) append<BgpFilterRuleAsPath>;
%template(appendCommunityRule) append<BgpFilterRuleCommunity>;
%template(appendRoute4Rule) append<BgpFilterRuleRoute4>;
%template(appendRoute6Rule) append<BgpFilterRuleRoute6>;
#endif

    BgpFilterOP apply(const Prefix &prefix, const std::vector<std::shared_ptr<BgpPathAttrib>> &attribs);
private:
    std::vector<std::shared_ptr<BgpFilterRule>> rules;
    BgpFilterOP default_op;
};

}

#endif // BGP_FILTER_H_