bgp-path-attrib.h

Go to the documentation of this file.

#ifndef BGP_PATH_ATTR_H
#define BGP_PATH_ATTR_H

#include "serializable.h"
#include "prefix6.h"
#include <stdint.h>
#include <unistd.h>
#include <vector>

namespace libbgp {

enum BgpPathAttribType {
    UNKNOW = -1,
    RESERVED = 0,
    ORIGIN = 1,
    AS_PATH = 2,
    NEXT_HOP = 3,
    MULTI_EXIT_DISC = 4,
    LOCAL_PREF = 5,
    ATOMIC_AGGREGATE = 6,
    AGGREATOR = 7,
    COMMUNITY = 8,
    MP_REACH_NLRI = 14,
    MP_UNREACH_NLRI = 15,
    AS4_PATH = 17,
    AS4_AGGREGATOR = 18
};

class BgpPathAttrib : public Serializable {
public:

    bool optional;

    bool transitive;

    bool partial;

    bool extended;

    uint8_t type_code;

    BgpPathAttrib(BgpLogHandler *logger);
    BgpPathAttrib(BgpLogHandler *logger, const uint8_t *value, uint16_t val_len);

    // get attribute type from buffer, return 0 if failed.
    static uint8_t GetTypeFromBuffer(const uint8_t *buffer, size_t buffer_sz);

    // print the attribute
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;

    virtual ssize_t parse(const uint8_t *from, size_t msg_sz);

    virtual ssize_t write(uint8_t *to, size_t buf_sz) const;

    virtual ssize_t length() const;

    BgpPathAttrib* clone(BgpLogHandler *new_logger) const;

    virtual BgpPathAttrib* clone() const;

    virtual ~BgpPathAttrib();

protected:
    // utility function to parse header (flags, typecode, length) from buffer
    ssize_t parseHeader(const uint8_t *buffer, size_t length);

    // utility function to print flags
    ssize_t printFlags(size_t indent, uint8_t **to, size_t *buf_sz) const;

    // utility function to write header (flags, type_code) to buffer. notice
    // that length is not write to buffer by this function.
    ssize_t writeHeader(uint8_t *buffer, size_t buffer_sz) const;

    uint16_t value_len;

private:
    uint8_t* value_ptr;
};

enum BgpPathAttribOrigins {
    IGP = 0,
    EGP = 1,
    INCOMPLETE = 2
};

class BgpPathAttribOrigin : public BgpPathAttrib {
public:
    BgpPathAttribOrigin(BgpLogHandler *logger);
    uint8_t origin;
    
    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

enum BgpAsPathSegmentType {
    AS_SET = 1,
    AS_SEQUENCE = 2
};

class BgpAsPathSegment {
public:
    BgpAsPathSegment(bool is_4b, uint8_t type);

    bool is_4b;

    uint8_t type;
    size_t getCount() const;
    bool prepend(uint32_t asn);

    std::vector<uint32_t> value;
};

class BgpPathAttribAsPath : public BgpPathAttrib {
public:
    // is_4b: 4b ASN in AS_PATH?
    BgpPathAttribAsPath(BgpLogHandler *logger, bool is_4b);

    BgpPathAttrib* clone() const;

    std::vector<BgpAsPathSegment> as_paths;

    bool is_4b;

    // prepend: utility function to prepend an ASN to path
    bool prepend(uint32_t asn);

    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
private:
    // addSeg: add a new AS_SEQUENCE with one ASN to AS_PATH 
    void addSeg(uint32_t asn);
};

class BgpPathAttribNexthop : public BgpPathAttrib {
public:
    BgpPathAttribNexthop(BgpLogHandler *logger);

    uint32_t next_hop;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribMed : public BgpPathAttrib {
public:
    BgpPathAttribMed(BgpLogHandler *logger);

    uint32_t med;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribLocalPref : public BgpPathAttrib {
public:
    BgpPathAttribLocalPref(BgpLogHandler *logger);

    uint32_t local_pref;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribAtomicAggregate : public BgpPathAttrib {
public:
    BgpPathAttribAtomicAggregate(BgpLogHandler *logger);

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribAggregator : public BgpPathAttrib {
public:
    // is_4b: 4b asn in aggregator?
    BgpPathAttribAggregator(BgpLogHandler *logger, bool is_4b);

    uint32_t aggregator;

    uint32_t aggregator_asn;

    bool is_4b;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribAs4Path : public BgpPathAttrib {
public:
    BgpPathAttribAs4Path(BgpLogHandler *logger);

    std::vector<BgpAsPathSegment> as4_paths;

    bool prepend(uint32_t asn);

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
private:
    void addSeg(uint32_t asn);
};

class BgpPathAttribAs4Aggregator : public BgpPathAttrib {
public:
    BgpPathAttribAs4Aggregator(BgpLogHandler *logger);

    uint32_t aggregator;

    uint32_t aggregator_asn4;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribCommunity : public BgpPathAttrib {
public:
    BgpPathAttribCommunity(BgpLogHandler *logger);

    std::vector<uint32_t> communites;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribMpNlriBase : public BgpPathAttrib {
public:
    BgpPathAttribMpNlriBase(BgpLogHandler *logger);
    static int16_t GetAfiFromBuffer(const uint8_t *buffer, size_t length);

    uint16_t afi;

    uint8_t safi;

protected:
    ssize_t parseHeader(const uint8_t *buffer, size_t length);
};

class BgpPathAttribMpReachNlriIpv6 : public BgpPathAttribMpNlriBase {
public:
    BgpPathAttribMpReachNlriIpv6(BgpLogHandler *logger);

    uint8_t nexthop_global[16];
    uint8_t nexthop_linklocal[16];
    std::vector<Prefix6> nlri;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribMpReachNlriUnknow : public BgpPathAttribMpNlriBase {
public:
    BgpPathAttribMpReachNlriUnknow(BgpLogHandler *logger);
    BgpPathAttribMpReachNlriUnknow(BgpLogHandler *logger, const uint8_t *nexthop, size_t nexthop_len, const uint8_t *nlri, size_t nlri_len);
    ~BgpPathAttribMpReachNlriUnknow();

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;

    const uint8_t *getNexthop() const;
    const uint8_t *getNlri() const;

    size_t getNexthopLength() const;
    size_t getNlriLength() const;

private:
    uint8_t *nexthop;
    size_t nexthop_len;
    uint8_t *nlri;
    size_t nlri_len;
};

class BgpPathAttribMpUnreachNlriIpv6 : public BgpPathAttribMpNlriBase {
public:
    BgpPathAttribMpUnreachNlriIpv6(BgpLogHandler *logger);
    std::vector<Prefix6> withdrawn_routes;

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;
};

class BgpPathAttribMpUnreachNlriUnknow : public BgpPathAttribMpNlriBase {
public:
    BgpPathAttribMpUnreachNlriUnknow(BgpLogHandler *logger);
    BgpPathAttribMpUnreachNlriUnknow(BgpLogHandler *logger, const uint8_t *withdrawn, size_t len);
    ~BgpPathAttribMpUnreachNlriUnknow();

    BgpPathAttrib* clone() const;
    ssize_t parse(const uint8_t *buffer, size_t length);
    ssize_t write(uint8_t *buffer, size_t buffer_sz) const;
    ssize_t doPrint(size_t indent, uint8_t **to, size_t *buf_sz) const;
    ssize_t length() const;

    const uint8_t *getWithdrawnRoutes() const;
    size_t getWithdrawnRoutesLength() const;
private:
    uint8_t *withdrawn_routes;
    size_t withdrawn_routes_len;
};

}
#endif // BGP_PATH_ATTR_H