bgp-fsm.h

Go to the documentation of this file.

#ifndef BGP_FSM_H_
#define BGP_FSM_H_
#define BGP_FSM_BUFFER_SIZE 4096

#include "clock.h"
#include "bgp-rib4.h"
#include "bgp-rib6.h"
#include "bgp-config.h"
#include "bgp-sink.h"
#include "route-event-receiver.h"
#include "bgp.h"
#include <stdint.h>
#include <unistd.h>
#include <mutex>

namespace libbgp {

enum BgpState {
    IDLE,
    OPEN_SENT,
    OPEN_CONFIRM,
    ESTABLISHED,
    BROKEN
};

class BgpFsm : public RouteEventReceiver {
public:
    BgpFsm(const BgpConfig &config);
    ~BgpFsm();

    uint32_t getAsn() const;

    uint32_t getBgpId() const;

    uint32_t getPeerAsn() const;

    uint32_t getPeerBgpId() const;

    uint16_t getHoldTimer() const;

    BgpRib4& getRib4() const;

    BgpRib6& getRib6() const;

    BgpState getState() const;

    int start();

    int stop();

    int run(const uint8_t *buffer, const size_t buffer_size);

    int tick();

    // soft reset: send Administrative Reset and go to idle
    // return value:
    // -1: fatal_error, FSM now BROKEN, check errbuf.
    // 0: success, NOTIFY sent, FSM not IDLE

    int resetSoft();

    // hard reset: go to idle
    void resetHard();

private:
    bool rib4_local;
    bool rib6_local;
    bool clock_local;
    bool log_local;
    bool rev_bus_exist;

    bool handleRouteEvent(const RouteEvent &ev);
    bool handleRouteCollisionEvent(const RouteCollisionEvent &ev);
    bool handleRoute4WithdrawEvent(const Route4WithdrawEvent &ev);
    bool handleRoute4AddEvent(const Route4AddEvent &ev);
    bool handleRoute6WithdrawEvent(const Route6WithdrawEvent &ev);
    bool handleRoute6AddEvent(const Route6AddEvent &ev);

    int validateState(uint8_t type);
    int fsmEvalIdle(const BgpMessage *msg);
    int fsmEvalOpenSent(const BgpMessage *msg);
    int fsmEvalOpenConfirm(const BgpMessage *msg);
    int fsmEvalEstablished(const BgpMessage *msg);

    // dropAll: drop all routes from peer and notify other FSMs w/ route event
    // bus (if exists) (called on FSM go from ESTABLISED to IDLE)
    void dropAllRoutes();

    // setState: set the state of FSM. additional operations may be performed.
    void setState(BgpState state);

    // validAddr4: valid an IPv4 address (nexthop/bgp_id), addr in network btye
    bool validAddr4(uint32_t addr) const;

    // validAddr6: valid an IPv6 address.
    bool validAddr6(const uint8_t addr[16]) const;

    // resloveCollison: resloving collsion
    // return value:
    // -1: fatal_error, FSM now BROKEN, check errbuf.
    // 0: there is a collision and this FSM should be dispose, FSM is now
    // IDLE and should be disposed
    // 1: there is a collision and the other FSM should be dispose.
    int resloveCollision(uint32_t peer_bgp_id, bool is_new);

    // since we handle open recv event in both idle and opensent, make it a func
    int openRecv(const BgpOpenMessage *open);

    bool writeMessage(const BgpMessage &msg);

    // automaically change IPv4 nexthop for outgoing routes if needed
    void alterNexthop4 (BgpUpdateMessage &update);

    // automaically change IPv4 nexthop for outgoing routes if needed
    void alterNexthop6 (const uint8_t* &nh_global, const uint8_t* &nh_local);

    // prepare update message for advertisement (prepend my_asn, remove 
    // non-trans attrs)
    void prepareUpdateMessage(BgpUpdateMessage &update);

    BgpSink in_sink;
    BgpState state;
    BgpConfig config;
    BgpRib4 *rib4;
    BgpRib6 *rib6;
    Clock *clock;
    BgpLogHandler *logger;

    std::recursive_mutex out_buffer_mutex;

    // pointer to output buffer
    uint8_t *out_buffer;

    // peer's bgp id
    uint32_t peer_bgp_id;

    // negotiated hold_timer
    uint16_t hold_timer;

    // time last event sent
    uint64_t last_sent;

    // time last event received
    uint64_t last_recv;

    // true if both peer & local support 4B ASN
    bool use_4b_asn;

    bool send_ipv4_routes;
    bool send_ipv6_routes;
    bool ibgp;

    uint32_t peer_asn;

};

}

#endif // BGP_FSM_H_