peer.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-

// Copyright (c) 2001-2009 XORP, Inc.
//
// 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

// $XORP: xorp/bgp/peer.hh,v 1.53 2008/11/08 06:14:37 mjh Exp $

#ifndef __BGP_PEER_HH__
#define __BGP_PEER_HH__

#include <sys/types.h>

#include "socket.hh"
#include "local_data.hh"
#include "peer_data.hh"

enum FSMState {
    STATEIDLE = 1,
    STATECONNECT = 2,
    STATEACTIVE = 3,
    STATEOPENSENT = 4,
    STATEOPENCONFIRM = 5,
    STATEESTABLISHED = 6,
    STATESTOPPED = 7    // This state is not in the protocol specification. 
            // After sending a notify it is necessary to
            // close the connection. Data transmission/reception 
            // is asynchronous, but the close is currently
            // synchronous. Thus the stopped state allows
            // us to wait for the notify to be sent to TCP,
            // before closing the connection.
};

enum FSMEvent {
    EVENTBGPSTART = 1,
    EVENTBGPSTOP = 2,
    EVENTBGPTRANOPEN = 3,
    EVENTBGPTRANCLOSED = 4,
    EVENTBGPCONNOPENFAIL = 5,
    EVENTBGPTRANFATALERR = 6,
    EVENTCONNTIMEEXP = 7,
    EVENTHOLDTIMEEXP = 8,
    EVENTKEEPALIVEEXP = 9,
    EVENTRECOPENMESS = 10,
    EVENTRECKEEPALIVEMESS = 11,
    EVENTRECUPDATEMESS = 12,
    EVENTRECNOTMESS = 13
};

enum PeerOutputState {
    PEER_OUTPUT_OK = 1,
    PEER_OUTPUT_BUSY = 2,
    PEER_OUTPUT_FAIL = 3
};

#define OPENMSGOK 0
#define UPDATEMSGOK 0

const uint32_t RIB_IPC_HANDLER_UNIQUE_ID = 0;
const uint32_t AGGR_HANDLER_UNIQUE_ID = 1;
const uint32_t UNIQUE_ID_START = AGGR_HANDLER_UNIQUE_ID + 1;

class BGPMain;
class PeerHandler;
class AcceptSession;

class DampPeerOscillations {
 public:
    DampPeerOscillations(EventLoop& eventloop, uint32_t restart_threshold,
             uint32_t time_period, uint32_t idle_holdtime);

    void restart();

    uint32_t idle_holdtime() const;

    void reset();
 private:
    EventLoop& _eventloop;      // Reference to the eventloop.
    const uint32_t _restart_threshold;  // Number of restart after
                    // which the idle holdtime
                    // will increase.
    const uint32_t _time_period;    // Period in seconds over
                    // which to sample errors.
    const uint32_t _idle_holdtime;  // Holdtime in seconds to use once the
                    // error threshold is passed.

    uint32_t _restart_counter;      // Count number of restarts in
                    // last time quantum.

    XorpTimer _zero_restart;        // Zero the restart counter.

    void zero_restart_count();
};

class BGPPeer {
public:
    BGPPeer(LocalData *ld, BGPPeerData *pd, SocketClient *sock, BGPMain *m);
    virtual ~BGPPeer();

    uint32_t get_unique_id() const  { return _unique_id; }

    void zero_stats();

    void clear_last_error();

    BGPPeerData *swap_peerdata(BGPPeerData *pd) {
    BGPPeerData *tmp = _peerdata;
    _peerdata = pd;

    return tmp;
    }

    void connected(XorpFd s);
    void remove_accept_attempt(AcceptSession *conn);
    SocketClient *swap_sockets(SocketClient *new_sock);
    XorpFd get_sock();

    void event_start();         // EVENTBGPSTART
    void event_stop(bool restart=false, bool automatic = false);// EVENTBGPSTOP
    void event_open();          // EVENTBGPTRANOPEN
    void event_open(const XorpFd sock); // EVENTBGPTRANOPEN
    void event_closed();        // EVENTBGPTRANCLOSED
    void event_openfail();      // EVENTBGPCONNOPENFAIL
    void event_tranfatal();     // EVENTBGPTRANFATALERR
    void event_connexp();       // EVENTCONNTIMEEXP
    void event_holdexp();       // EVENTHOLDTIMEEXP
    void event_keepexp();       // EVENTKEEPALIVEEXP
    void event_delay_open_exp();    // Event 12: DelayOpenTimer_Expires
    void event_idle_hold_exp();     // Event 13: IdleHoldTimer_Expires
    void event_openmess(const OpenPacket& p);   // EVENTRECOPENMESS
    void event_keepmess();          // EVENTRECKEEPALIVEMESS
    void event_recvupdate(UpdatePacket& p);     // EVENTRECUPDATEMESS
    void event_recvnotify(const NotificationPacket& p); // EVENTRECNOTMESS

    void generate_open_message(OpenPacket& open);
    void notify_peer_of_error(const int error,
                  const int subcode = UNSPECIFIED,
                  const uint8_t*data = 0,
                  const size_t len = 0);

    FSMState state()            { return _state; }
    static const char *pretty_print_state(FSMState s);

    TimeVal jitter(const TimeVal& t);

    void clear_all_timers();
    void start_connect_retry_timer();
    void clear_connect_retry_timer();
    void restart_connect_retry_timer();

    void start_keepalive_timer();
    void clear_keepalive_timer();

    void start_hold_timer();
    void clear_hold_timer();
    void restart_hold_timer();

    void start_stopped_timer();
    void clear_stopped_timer();

    void start_idle_hold_timer();
    void clear_idle_hold_timer();
    bool running_idle_hold_timer() const;

    void start_delay_open_timer();
    void clear_delay_open_timer();

    bool get_message(BGPPacket::Status status, const uint8_t *buf, size_t len,
             SocketClient *socket_client);
    PeerOutputState send_message(const BGPPacket& p);
    void send_message_complete(SocketClient::Event, const uint8_t *buf);

    string str() const          { return _peername; }
    bool is_connected() const       { return _SocketClient->is_connected(); }
    bool still_reading() const      { return _SocketClient->still_reading(); }
    LocalData* localdata()              { return _localdata; }
    IPv4 id() const             { return _localdata->get_id(); }
    BGPMain* main() const       { return _mainprocess; }
    const BGPPeerData* peerdata() const { return _peerdata; }
    bool ibgp() const           { return peerdata()->ibgp(); }
    bool use_4byte_asnums() const { 
    return _peerdata->use_4byte_asnums(); 
    }
    bool we_use_4byte_asnums() const { 
    return _localdata->use_4byte_asnums(); 
    }

    bool send_netreachability(const BGPUpdateAttrib &n);
    /*
    ** Virtual so that it can be subclassed in the plumbing test code.
    */
    virtual PeerOutputState send_update_message(const UpdatePacket& p);

    uint32_t get_established_transitions() const {
    return _established_transitions;
    }
    uint32_t get_established_time() const;
    void get_msg_stats(uint32_t& in_updates, 
               uint32_t& out_updates, 
               uint32_t& in_msgs, 
               uint32_t& out_msgs, 
               uint16_t& last_error, 
               uint32_t& in_update_elapsed) const;
protected:
private:
    LocalData* _localdata;

    static uint32_t _unique_id_allocator;
    const uint32_t _unique_id;

    friend class BGPPeerList;

    void connect_to_peer(SocketClient::ConnectCallback cb) {
    XLOG_ASSERT(_SocketClient);
    _SocketClient->connect(cb);
    }
    void connect_to_peer_complete(bool success) {
    if (success)
        event_open();       // Event = EVENTBGPTRANOPEN
    else
        event_openfail();       // Event = EVENTBGPCONNOPENFAIL
    }

    void send_notification(const NotificationPacket& p, bool restart = true,
               bool automatic = true);
    void send_notification_complete(SocketClient::Event, const uint8_t *buf,
                    bool restart, bool automatic);
    void flush_transmit_queue()     { _SocketClient->flush_transmit_queue(); }
    void stop_reader()          { _SocketClient->stop_reader(); }

    SocketClient *_SocketClient;
    bool _output_queue_was_busy;
    FSMState _state;

    BGPPeerData* _peerdata;
    BGPMain* _mainprocess;
    PeerHandler *_handler;
    list<AcceptSession *> _accept_attempt;
    string _peername;

    XorpTimer _timer_connect_retry;
    XorpTimer _timer_hold_time;
    XorpTimer _timer_keep_alive;
    XorpTimer _idle_hold;
    XorpTimer _delay_open;

    // counters needed for the BGP MIB
    uint32_t _in_updates;
    uint32_t _out_updates;
    uint32_t _in_total_messages;
    uint32_t _out_total_messages;
    uint8_t _last_error[2];
    uint32_t _established_transitions;
    TimeVal _established_time;
    TimeVal _in_update_time;

    XorpTimer _timer_stopped;
    void hook_stopped();

    void check_open_packet(const OpenPacket *p) throw (CorruptMessage);
    NotificationPacket* check_update_packet(const UpdatePacket *p,
                        bool& good_nexthop);

    bool established();

    bool release_resources();

    void set_state(FSMState s, bool restart = true, bool automatic = true);
    bool remote_ip_ge_than(const BGPPeer& peer);

    bool _damping_peer_oscillations;    // True if Damp Peer
                    // Oscillations is enabled.
    DampPeerOscillations _damp_peer_oscillations;
    
    void automatic_restart();
    
private:
    friend class BGPMain;

    bool _current_state;
    void set_current_peer_state(bool state) {_current_state = state;}
    bool get_current_peer_state() {return _current_state;}

    bool _next_state;
    void set_next_peer_state(bool state) {_next_state = state;}
    bool get_next_peer_state() {return _next_state;}

    bool _activated;
    void set_activate_state(bool state) {_activated = state;}
    bool get_activate_state() {return _activated;}
};

/*
 * All incoming TCP connection attempts are handled through this class.
 * The BGPPeer class handles outgoing connection attempts.
 *
 * Under normal circumstances only one connection attempt will be
 * taking place. When both BGP processes at either end of a session
 * attempt to make a connection at the same time there may be a
 * connection collision in this case it is necessary to hold two TCP
 * connections until an open message is seen by the peer to decide
 * which session should be selected. If a connection collision is
 * detected this class does *not* send an open message, it waits for
 * the peers open message. It should be noted that the BGPPeer class
 * is not aware that a connection collision condition exists, hence it
 * does not check the IDs. The assumptions are that:
 * 1) The IDs will be identical in both open messages so it's only
 *    necessary to check one of the two open messages.
 * 2) A BGP process will actually send a open message after making a
 *    connection. 
 *
 * This class could be used to get rid of the XORP invented STOPPED
 * state in state machine.
 */
class AcceptSession {
 public:
     AcceptSession(BGPPeer& peer, XorpFd sock);

     ~AcceptSession();

     void start();

     void no_open_received();

     void remove();

     void send_notification_accept(const NotificationPacket& np);

     void send_notification_cb(SocketClient::Event ev, const uint8_t* buf);

     void cease();

     void collision();

     void event_openmess_accept(const OpenPacket& p);

     void swap_sockets();

     void swap_sockets(const OpenPacket& p);


     void notify_peer_of_error_accept(const int error,
                      const int subcode = UNSPECIFIED,
                      const uint8_t*data = 0,
                      const size_t len = 0);

     void event_tranfatal_accept();

     void event_closed_accept();

     void event_keepmess_accept();

     void event_recvupdate_accept(const UpdatePacket& p);

     void event_recvnotify_accept(const NotificationPacket& p);

     bool get_message_accept(BGPPacket::Status status, const uint8_t *buf,
                 size_t len, SocketClient *socket_client);

     bool is_connected() { return _socket_client->is_connected(); }

     bool still_reading() { return _socket_client->still_reading(); }

     void ignore_message() { _accept_messages = false; }

     bool accept_message() const { return _accept_messages; }

     string str() {
     return _peer.str();
     }

 private:
     BGPPeer& _peer;
     XorpFd _sock;
     SocketClient *_socket_client;
     bool _accept_messages;

     XorpTimer _open_wait;  // Wait for an open message from the peer.

     BGPMain *main()            { return _peer.main(); }
     FSMState state()           { return _peer.state(); }
     const BGPPeerData* peerdata() const{ return _peer.peerdata(); }
     bool running_idle_hold_timer() const {
    return _peer.running_idle_hold_timer();
     } 
};

#endif // __BGP_PEER_HH__