peer.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2012 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU General Public License is not permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net


#ifndef __OSPF_PEER_HH__
#define __OSPF_PEER_HH__

template <typename A> class Ospf;
template <typename A> class Peer;

#include "auth.hh"

template <typename A>
class PeerOut {
 public:

    PeerOut(Ospf<A>& ospf, const string interface, const string vif, 
        OspfTypes::PeerID peerid, const A source,
        OspfTypes::LinkType linktype, OspfTypes::AreaID area,
        OspfTypes::AreaType area_type);

    ~PeerOut();

    string get_if_name() const { return _interface + "/" + _vif; }

    bool match(A source, string& interface, string& vif);

    OspfTypes::PeerID get_peerid() const { return _peerid; }

    bool set_interface_address(A interface_address) {
    _interface_address = interface_address;
    return true;
    }

    A get_interface_address() const { return _interface_address; }

    uint16_t get_interface_prefix_length() const;

    uint16_t get_interface_mtu() const {
    XLOG_ASSERT(0 != _interface_mtu);
    return _interface_mtu;
    }

    uint16_t get_frame_size() const;

    void join_multicast_group(A address) {
    _ospf.join_multicast_group(_interface, _vif, address);
    }

    void leave_multicast_group(A address) {
    _ospf.leave_multicast_group(_interface, _vif, address);
    }

    uint16_t get_interface_cost() const {
    return _interface_cost;
    }

    uint16_t get_inftransdelay() const {
    return _inftransdelay;
    }

    bool get_areas(list<OspfTypes::AreaID>& areas) const;

    bool add_area(OspfTypes::AreaID area, OspfTypes::AreaType area_type);

    bool change_area_router_type(OspfTypes::AreaID area,
                 OspfTypes::AreaType area_type);

    bool remove_area(OspfTypes::AreaID area);

    bool add_neighbour(OspfTypes::AreaID area, A neighbour_address,
               OspfTypes::RouterID);

    bool remove_neighbour(OspfTypes::AreaID area, A neighbour_address,
              OspfTypes::RouterID rid);
    
    void set_state(bool state);

    bool get_state() const {
    return _running;
    }

    void set_link_status(bool status, const char* dbg);

    void peer_change();

    bool transmit(typename Transmit<A>::TransmitRef tr);

    bool receive(A dst, A src, Packet *packet) throw(BadPeer);

    bool send_lsa(OspfTypes::AreaID area, const OspfTypes::NeighbourID nid,
          Lsa::LsaRef lsar);

    bool queue_lsa(OspfTypes::PeerID peerid, OspfTypes::NeighbourID nid,
           Lsa::LsaRef lsar, bool &multicast_on_peer) const;
    
    bool push_lsas(const char* message);

    bool neighbours_exchange_or_loading(OspfTypes::AreaID area);

    bool neighbour_at_least_two_way(OspfTypes::AreaID area,
                    OspfTypes::RouterID rid, bool& twoway);

    bool get_neighbour_address(OspfTypes::AreaID area,
                   OspfTypes::RouterID rid,
                   uint32_t interface_id,
                   A& neighbour_address);

    bool on_link_state_request_list(OspfTypes::AreaID area,
                    const OspfTypes::NeighbourID nid,
                    Lsa::LsaRef lsar);
    
    bool event_bad_link_state_request(OspfTypes::AreaID area,
                      const OspfTypes::NeighbourID nid);

    bool virtual_link_endpoint(OspfTypes::AreaID area);

    OspfTypes::LinkType get_linktype() const { return _linktype; }

    // Configure the peering.

    void router_id_changing();

    bool set_interface_id(uint32_t interface_id);

    uint32_t get_interface_id() const { return _interface_id; }
    
    bool get_attached_routers(OspfTypes::AreaID area,
                  list<RouterInfo>& routes);

    bool add_advertise_net(OspfTypes::AreaID area, A addr, uint32_t prefix);

    bool remove_all_nets(OspfTypes::AreaID area);

    bool update_nets(OspfTypes::AreaID area);

    bool set_hello_interval(OspfTypes::AreaID area, uint16_t hello_interval);

    bool set_options(OspfTypes::AreaID area, uint32_t options);

    bool set_router_priority(OspfTypes::AreaID area, uint8_t priority);

    bool set_router_dead_interval(OspfTypes::AreaID area,
                  uint32_t router_dead_interval);

    bool set_simple_authentication_key(OspfTypes::AreaID area,
                       const string& password,
                       string& error_msg);

    bool delete_simple_authentication_key(OspfTypes::AreaID area,
                      string& error_msg);

    bool set_md5_authentication_key(OspfTypes::AreaID area, uint8_t key_id,
                    const string& password,
                    const TimeVal& start_timeval,
                    const TimeVal& end_timeval,
                    const TimeVal& max_time_drift,
                    string& error_msg);

    bool delete_md5_authentication_key(OspfTypes::AreaID area, uint8_t key_id,
                       string& error_msg);

    bool set_passive(OspfTypes::AreaID area, bool passive, bool host);

    bool set_interface_cost(uint16_t interface_cost);

    bool set_retransmit_interval(OspfTypes::AreaID area,
                 uint16_t retransmit_interval);

    bool set_inftransdelay(uint16_t inftransdelay) {
    _inftransdelay = inftransdelay;
    return true;
    }

    bool get_neighbour_list(list<OspfTypes::NeighbourID>& neighbours) const;

    bool get_neighbour_info(OspfTypes::NeighbourID nid,
                NeighbourInfo& ninfo) const;

    set<AddressInfo<A> >& get_address_info(OspfTypes::AreaID area);

    void start_receiving_packets();

    void stop_receiving_packets();

 private:
    Ospf<A>& _ospf;         // Reference to the controlling class.

    const string _interface;        // The interface and vif this peer is
    const string _vif;          // responsible for.
    const OspfTypes::PeerID _peerid;    // The peers ID.
    uint32_t _interface_id;     // Inferface ID OSPFv3 only.
    A _interface_address;       // Interface address.
    uint16_t _interface_prefix_length;  // Interface prefix length
    uint16_t _interface_mtu;        // MTU of this interface.
    uint16_t _interface_cost;       // Cost of this interface.
    uint16_t _inftransdelay;        // InfTransDelay.

    const OspfTypes::LinkType _linktype;    // Type of this link.

                    //  Areas being served.
    map<OspfTypes::AreaID, Peer<A> *>  _areas; 

    // In order for the peer to be up and running the peer has to be
    // configured up and the link also has to be up.

    bool _running;          // True if the peer is up and running
    bool _link_status;          // True if the link is up,
                    // cable connected and
                    // interface/vif/address
                    // configured up.
    bool _status;           // True if the peer has been
                    // configured up.

    set<AddressInfo<A> > _dummy;    // If get_address_info fails
                    // return a reference to this
                    // dummy entry 
    bool _receiving;            // Are we currently enabled
                    // for receiving packets.

    void set_mask(Peer<A> *peer);

    // In order to maintain the requirement for an interpacket gap,
    // all outgoing packets are appended to this queue. Then they are
    // read off the queue and transmitted at the interpacket gap rate.
    queue<typename Transmit<A>::TransmitRef> _transmit_queue;   

    bool bring_up_peering();
    void take_down_peering();

    bool get_passive();
};

template <typename A> class Neighbour;

template <typename A>
class Peer {
 public:
    enum InterfaceState {
    Down,
    Loopback,
    Waiting,
    Point2Point,
    DR_other,
    Backup,
    DR,
    };

    Peer(Ospf<A>& ospf, PeerOut<A>& peerout, OspfTypes::AreaID area_id,
     OspfTypes::AreaType area_type)
    : _ospf(ospf), _peerout(peerout), _area_id(area_id),
      _area_type(area_type), _go_called(false),
      _enabled(false), _passive(false), _passive_host(false),
      _auth_handler(_ospf.get_eventloop()),
      _interface_state(Down),
      _hello_packet(ospf.get_version())
    {
    _hello_packet.set_area_id(area_id);

    // Some defaults taken from the Juniper manual. These values
    // should be overriden by the values in the templates files.
    // For testing set some useful values
    _hello_packet.set_hello_interval(10);
    _hello_packet.set_router_priority(128);

    // RFC 2328 Appendix C.3 Router Interface Parameters
    _hello_packet.
        set_router_dead_interval(4 * _hello_packet.get_hello_interval());
    _rxmt_interval = 5;

    init();
    }

    ~Peer() {
    typename list<Neighbour<A> *>::iterator n;
    for (n = _neighbours.begin(); n != _neighbours.end(); n++)
        delete (*n);
    _neighbours.clear();

    shutdown();
    }

    bool init() {
    bool status = true;
    switch(_ospf.get_version()) {
        case OspfTypes::V2:
        break;
        case OspfTypes::V3:
        status = initV3();
        break;
    }
    return status;
    }

    bool shutdown() {
    bool status = true;
    if (!_go_called)
        return status;
    else
        _go_called = false;
    switch(_ospf.get_version()) {
        case OspfTypes::V2:
        break;
        case OspfTypes::V3:
        status = shutdownV3();
        break;
    }
    return status;
    }

    bool go() {
    bool status = true;
    XLOG_ASSERT(!_go_called);
    _go_called = true;
    switch(_ospf.get_version()) {
        case OspfTypes::V2:
        break;
        case OspfTypes::V3:
        status = goV3();
        break;
    }
    return status;
    }

    bool initV3();

    bool goV3();

    bool shutdownV3();

    /*
     * OSPFv3 set all the fields for the peers Link-LSA.
     */
    void populate_link_lsa();

    bool match(IPv6 source) const;

    string get_if_name() const { return _peerout.get_if_name(); }

    OspfTypes::PeerID get_peerid() const { return _peerout.get_peerid(); }

    A get_interface_address() const { 
    return _peerout.get_interface_address();
    }
    
    uint16_t get_interface_prefix_length() const {
    return _peerout.get_interface_prefix_length();
    }

#if 0

    A get_p2p_neighbour_address() const {
    XLOG_ASSERT(OspfTypes::PointToPoint == get_linktype());
    XLOG_ASSERT(1 == _neighbours.size());

    // When an P2P interface is configured a single neighbour will
    // exist. Fetch the address from the neighbour structure.
    typename list<Neighbour<A> *>::const_iterator ni = _neighbours.begin();
    XLOG_ASSERT(ni != _neighbours.end());

    return (*ni)->get_neighbour_address();
    }
#endif

    uint16_t get_interface_mtu() const {
    return _peerout.get_interface_mtu();
    }

    uint16_t get_frame_size() const {
    return _peerout.get_frame_size() - _auth_handler.additional_payload();
    }

    uint16_t get_inftransdelay() const {
    return _peerout.get_inftransdelay();
    }

    bool transmit(typename Transmit<A>::TransmitRef tr) {
    return _peerout.transmit(tr);
    }

    bool add_neighbour(A neighbour_address, OspfTypes::RouterID rid);

    bool remove_neighbour(A neighbour_address, OspfTypes::RouterID rid);

    bool belongs(A addr) const;

    bool receive(A dst, A src, Packet *packet);

    bool accept_lsa(Lsa::LsaRef lsar) const;

    bool send_lsa(const OspfTypes::NeighbourID nid, Lsa::LsaRef lsar) const;

    bool queue_lsa(OspfTypes::PeerID peerid, OspfTypes::NeighbourID nid,
           Lsa::LsaRef lsar, bool& multicast_on_peer) const;

    bool push_lsas(const char* message);

    /*
     * Should we be computing the DR and BDR on this peer?
     * Another way of phrasing this is, is the linktype BROADCAST or NBMA?
     */
    bool do_dr_or_bdr() const;

    bool is_DR() const;

    bool is_BDR() const;

    bool is_DR_or_BDR() const;

    bool neighbours_exchange_or_loading() const;

    bool neighbour_at_least_two_way(OspfTypes::RouterID rid, bool& twoway);

    bool get_neighbour_address(OspfTypes::RouterID rid, uint32_t interface_id,
                   A& neighbour_address);

    bool on_link_state_request_list(const OspfTypes::NeighbourID nid,
                    Lsa::LsaRef lsar) const;

    bool event_bad_link_state_request(const OspfTypes::NeighbourID nid) const;

    bool virtual_link_endpoint() const;

    void send_direct_acks(OspfTypes::NeighbourID nid,
             list<Lsa_header>& ack);

    void send_delayed_acks(OspfTypes::NeighbourID nid,
              list<Lsa_header>& ack);

    /*
     * Find neighbour that this address or router ID is associated
     * with. If the linktype is Virtual Link or PointToPoint the
     * router ID is used otherwise the src address is used.
     *
     * @param src address of neighbour.
     * @param rid router ID of neighbour
     *
     * @return neighbour or 0 if no match.
     */
    Neighbour<A> *find_neighbour(A src, OspfTypes::RouterID rid);

    bool is_neighbour_DR_or_BDR(OspfTypes::NeighbourID nid) const;

    bool process_hello_packet(A dst, A src, HelloPacket *hello);

    bool process_data_description_packet(A dst, A src,
                     DataDescriptionPacket *dd);

    bool process_link_state_request_packet(A dst, A src,
                       LinkStateRequestPacket *lsrp);

    bool process_link_state_update_packet(A dst, A src,
                       LinkStateUpdatePacket *lsup);

    bool
    process_link_state_acknowledgement_packet(A dst, A src,
                          LinkStateAcknowledgementPacket
                          *lsap);

    void start();

    void stop();

    void change_area_router_type(OspfTypes::AreaType area_type);

    void event_interface_up();

    void event_wait_timer();

    void event_backup_seen();

    void event_neighbour_change();

    void event_loop_ind();

    void event_unloop_ind();

    void event_interface_down();

    void schedule_event(const char *);

    void process_scheduled_events();

    AreaRouter<A> *get_area_router() {
    AreaRouter<A> *area_router = 
        _ospf.get_peer_manager().get_area_router(get_area_id());
    XLOG_ASSERT(area_router);
    return area_router;
    }

    static OspfTypes::RouterID get_candidate_id(A, OspfTypes::RouterID);

    OspfTypes::RouterID get_candidate_id(A = A::ZERO()) const;

    InterfaceState get_state() const { return _interface_state; }

    OspfTypes::LinkType get_linktype() const {
    return _peerout.get_linktype();
    }

    Auth& get_auth_handler() { return _auth_handler; }

#if 0

    uint32_t send_options();
#endif

    void populate_common_header(Packet& packet);

    static string pp_interface_state(InterfaceState is);

    OspfTypes::AreaID get_area_id() const { return _area_id; }

    OspfTypes::AreaType get_area_type() const { return _area_type; }

    void set_area_type(OspfTypes::AreaType area_type) {
    _area_type = area_type;
    }

    void router_id_changing();

    bool set_network_mask(uint32_t network_mask);

    uint32_t get_network_mask() const;

    bool set_interface_id(uint32_t interface_id);

    uint32_t get_interface_id() const;

    bool add_advertise_net(A addr, uint32_t prefix);

    bool remove_all_nets();

    bool update_nets();

    bool set_hello_interval(uint16_t hello_interval);

    bool set_options(uint32_t options);

    uint32_t get_options() const;

    bool set_router_priority(uint8_t priority);

    bool set_router_dead_interval(uint32_t router_dead_interval);

    uint32_t get_router_dead_interval() const;

    bool set_simple_authentication_key(const string& password,
                       string& error_msg);

    bool delete_simple_authentication_key(string& error_msg);

    bool set_md5_authentication_key(uint8_t key_id, const string& password,
                    const TimeVal& start_timeval,
                    const TimeVal& end_timeval,
                    const TimeVal& max_time_drift,
                    string& error_msg);

    bool delete_md5_authentication_key(uint8_t key_id, string& error_msg);

    bool set_passive(bool passive, bool host);

    bool get_passive() const;

    bool set_rxmt_interval(uint32_t rxmt_interval);

    uint32_t get_rxmt_interval();
    
    OspfTypes::RouterID get_designated_router() const;

    OspfTypes::RouterID get_backup_designated_router() const;
    
    uint32_t get_designated_router_interface_id(A = A::ZERO()) const;

    void update_router_links();

    void adjacency_change(bool up);

    bool get_neighbour_list(list<OspfTypes::NeighbourID>& neighbours) const;

    bool get_neighbour_info(OspfTypes::NeighbourID nid,
                NeighbourInfo& ninfo) const;

    set<AddressInfo<A> >& get_address_info();

    bool get_attached_routers(list<RouterInfo>& routers);

 private:
    Ospf<A>& _ospf;         // Reference to the controlling class.
    PeerOut<A>& _peerout;       // Reference to PeerOut class.
    const OspfTypes::AreaID _area_id;   // Area that is being represented.
    OspfTypes::AreaType _area_type; // NORMAL or STUB or NSSA.
    bool _go_called;            // True if go() has been called.
    bool _enabled;          // True if the interface is enabled.
    bool _passive;          // True if the interface is in loopback
    bool _passive_host;         // True for host, False for
                    // network when in loopback i.e.
                    // (_passive == True).

    Auth _auth_handler;         // The authentication handler.

    XorpTimer _hello_timer;     // Timer used to fire hello messages.
    XorpTimer _wait_timer;      // Wait to discover other DRs.
    XorpTimer _event_timer;     // Defer event timer.

    uint32_t _rxmt_interval;        // The number of seconds
                    // between transmission for:
                    // LSAs, DDs and LSRPs.

    InterfaceState _interface_state;

    list<Neighbour<A> *> _neighbours;   // List of discovered neighbours.

    HelloPacket _hello_packet;      // Packet that is sent by this peer.

    Lsa::LsaRef _link_lsa;      // This interfaces OSPFv3 Link-LSA. 

    list<RouterLink> _router_links; // Router links for this peer

    struct Candidate {
    Candidate(OspfTypes::RouterID candidate_id,
          OspfTypes::RouterID router_id, OspfTypes::RouterID dr,
          OspfTypes::RouterID bdr, uint8_t router_priority) 
        : _candidate_id(candidate_id), _router_id(router_id), _dr(dr),
          _bdr(bdr), _router_priority(router_priority)
    {}

    // OSPFv2 the candidate ID is the interface address.
    // OSPFv3 the candidate ID is the Router ID.
    OspfTypes::RouterID _candidate_id;// Candidate's ID
    OspfTypes::RouterID _router_id; // Router ID
    OspfTypes::RouterID _dr;    // Designated router.
    OspfTypes::RouterID _bdr;   // Backup Designated router.
    uint8_t  _router_priority;  // Router Priority.

    string str() const {
        return c_format("CID %s RID %s DR %s BDR %s PRI %d",
                pr_id(_candidate_id).c_str(),
                pr_id(_router_id).c_str(),
                pr_id(_dr).c_str(),
                pr_id(_bdr).c_str(),
                _router_priority);
    }
    };

    list<string> _scheduled_events; // List of deferred events.

    set<AddressInfo<A> > _address_info; // Set of addresses that have
                    // been configured with this
                    // peer. Only the peer manager
                    // should access this data
                    // structure. 

    void change_state(InterfaceState state);

    void set_state(InterfaceState state) {_interface_state = state; }

    bool set_designated_router(OspfTypes::RouterID dr);

    bool set_backup_designated_router(OspfTypes::RouterID dr);

    void designated_router_changed(bool yes);

    void start_hello_timer();

    void stop_hello_timer();

    void restart_hello_timer();

    void start_wait_timer();
    void stop_wait_timer();

    bool send_hello_packet();
    
    OspfTypes::RouterID
    backup_designated_router(list<Candidate>& candidates) const;
    OspfTypes::RouterID
    designated_router(list<Candidate>& candidates,
              OspfTypes::RouterID backup_designated_router) const;

    void compute_designated_router_and_backup_designated_router();

    void update_router_linksV2(list<RouterLink>& router_links);

    void update_router_linksV3(list<RouterLink>& router_links);

    void remove_neighbour_state();

    void tear_down_state();
};

class RxmtWrapper;

template <typename A>
class Neighbour {
 public:
    enum State {
    Down = 1,
    Attempt = 2,
    Init = 3,
    TwoWay = 4,
    ExStart = 5,
    Exchange = 6,
    Loading = 7,
    Full = 8
    };

    static const uint32_t TIMERS = 2;   // Number of timers

    enum Timers {
    INITIAL = 0,    // Database exchanges.
    FULL = 1,   // LSA requests and retransmissions.
    };

    typedef XorpCallback0<bool>::RefPtr RxmtCallback;

    Neighbour(Ospf<A>& ospf, Peer<A>& peer, OspfTypes::RouterID router_id,
          A neighbour_address, OspfTypes::NeighbourID neighbourid,
          OspfTypes::LinkType linktype, 
          State state = Init)
    : _ospf(ospf), _peer(peer), _router_id(router_id),
      _neighbour_address(neighbour_address),
      _neighbourid(neighbourid),
      _linktype(linktype),
      _state(state), _hello_packet(0),
      _last_dd(ospf.get_version()),
      _data_description_packet(ospf.get_version())
    {
    // No neighbour should ever have this ID.
    XLOG_ASSERT(OspfTypes::ALLNEIGHBOURS != neighbourid);
    
    for (uint32_t i = 0; i < TIMERS; i++)
        _rxmt_wrapper[i] = 0;

    TimeVal t;
    _ospf.get_eventloop().current_time(t);
    // If we are debugging numbers starting from 0 are easier to
    // deal with.
#ifdef  DEBUG_LOGGING
    _data_description_packet.set_dd_seqno(0);
#else
    _data_description_packet.set_dd_seqno(t.sec());
#endif
    _creation_time = t;
    }

    ~Neighbour() {
    delete _hello_packet;
    for (uint32_t i = 0; i < TIMERS; i++)
        delete _rxmt_wrapper[i];
    }

    OspfTypes::NeighbourID get_neighbour_id() const {
    return _neighbourid;
    }

    OspfTypes::RouterID get_router_id() const { 
    if (_hello_packet)
        return _hello_packet->get_router_id();
    return _router_id;
    }

    A get_neighbour_address() const { return _neighbour_address; }

    OspfTypes::RouterID get_candidate_id() const {
    return Peer<A>::get_candidate_id(_neighbour_address, get_router_id());
    }

    State get_state() const { return _state; }

    Auth& get_auth_handler() { return _peer.get_auth_handler(); }

    bool is_neighbour_DR() const;

    bool is_neighbour_DR_or_BDR() const;

    bool announce_in_hello_packet() const {
    return _hello_packet;
    }
    
    HelloPacket *get_hello_packet() { return _hello_packet; }

    HelloPacket *get_hello_packet() const { return _hello_packet; }

    void event_hello_received(HelloPacket *hello);

    void data_description_received(DataDescriptionPacket *dd);

    void link_state_request_received(LinkStateRequestPacket *lsrp);

    void link_state_update_received(LinkStateUpdatePacket *lsup);

    void link_state_acknowledgement_received(LinkStateAcknowledgementPacket
                         *lsap);

    bool send_lsa(Lsa::LsaRef lsar);

    bool queue_lsa(OspfTypes::PeerID peerid, OspfTypes::NeighbourID nid,
           Lsa::LsaRef lsar, bool& multicast_on_peer);

    bool push_lsas(const char* message);

    bool on_link_state_request_list(Lsa::LsaRef lsar) const;

    OspfTypes::LinkType get_linktype() const { return _linktype; }

    bool send_ack(list<Lsa_header>& ack, bool direct, bool& multicast_on_peer);

    void event_kill_neighbour();
    void event_adj_ok();
    void event_bad_link_state_request();

    static const char* pp_state(State is);

    bool get_neighbour_info(NeighbourInfo& ninfo) const;

    string str() {
    return "Address: " + _neighbour_address.str() +
        "RouterID: " + pr_id(get_router_id());
    }

    static OspfTypes::NeighbourID _ticket;  // Allocator for NeighbourID's
 private:
    Ospf<A>& _ospf;         // Reference to the controlling class.
    Peer<A>& _peer;         // Reference to Peer class.
    const OspfTypes::RouterID _router_id;// Neighbour's RouterID.
    const A _neighbour_address;     // Neighbour's address.
    const OspfTypes::NeighbourID _neighbourid;  // The neighbours ID.
    const OspfTypes::LinkType _linktype;    // Type of this link.

    State _state;           // State of this neighbour.
    HelloPacket *_hello_packet;     // Last hello packet received
                    // from this neighbour.
    DataDescriptionPacket _last_dd; // Saved state from Last DDP received.
                    // The DDP this neighbour sends.
    DataDescriptionPacket _data_description_packet;
    bool _all_headers_sent;     // Tracking database transmssion

    XorpTimer _rxmt_timer[TIMERS];  // Retransmit timers.
    RxmtWrapper *_rxmt_wrapper[TIMERS]; // Wrappers to retransmiter.

    DataBaseHandle _database_handle;    // Handle to the Link State Database.
    list<Lsa_header> _ls_request_list;  // Link state request list.

    list<Lsa::LsaRef> _lsa_queue;   // Queue of LSAs waiting to be sent.
    list<Lsa::LsaRef> _lsa_rxmt;    // Unacknowledged LSAs
                    // awaiting retransmission.
    XorpTimer _inactivity_timer;    // Inactivity timer.

    TimeVal _creation_time;     // Creation time.
    TimeVal _adjacency_time;        // Adjacency time.

    AreaRouter<A> *get_area_router() {return _peer.get_area_router(); }
      
    void change_state(State state);

    void set_state(State state) {_state = state; }

    bool establish_adjacency_p() const;

    bool is_DR() const;

    bool is_BDR() const;

    bool is_DR_or_BDR() const;

    void start_inactivity_timer();

    void stop_inactivity_timer();

    void start_rxmt_timer(uint32_t index, RxmtCallback, bool immediate, 
              const char *comment);

    void stop_rxmt_timer(uint32_t index, const char *comment);

    void ensure_retransmitter_running(const char* comment);

    bool retransmitter();

    void build_data_description_packet();

    bool send_data_description_packet();

    void start_sending_data_description_packets(const char *event_name,
                        bool immediate = true);

    bool extract_lsa_headers(DataDescriptionPacket *dd);

    bool send_link_state_request_packet(LinkStateRequestPacket& lsrp);

    bool send_link_state_update_packet(LinkStateUpdatePacket& lsup,
                       bool direct = false);

    bool send_link_state_ack_packet(LinkStateAcknowledgementPacket& lsap,
                    bool direct,
                    bool& multicast_on_peer);

    void tear_down_state(State previous_state);

    void event_1_way_received();
    void event_2_way_received();
    void event_negotiation_done();
    void event_sequence_number_mismatch();
    void event_exchange_done();
    void event_loading_done();
    void event_inactivity_timer();

    void event_SequenceNumberMismatch_or_BadLSReq(const char *event_name);
};


#endif // __OSPF_PEER_HH__