io_ip_manager.hh

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

// Copyright (c) 2001-2011 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 __FEA_IO_IP_MANAGER_HH__
#define __FEA_IO_IP_MANAGER_HH__


#include "libxorp/callback.hh"
#include "libxorp/ipvx.hh"
#include "libxorp/xorpfd.hh"

#include "fea_io.hh"
#include "io_ip.hh"

class FeaDataPlaneManager;
class FeaNode;
class IoIpManager;


struct IPvXHeaderInfo {
    string  if_name;
    string  vif_name;
    IPvX    src_address;
    IPvX    dst_address;
    uint8_t ip_protocol;
    int32_t ip_ttl;
    int32_t ip_tos;
    bool    ip_router_alert;
    bool    ip_internet_control;
    vector<uint8_t> ext_headers_type;
    vector<vector<uint8_t> > ext_headers_payload;
};

class IoIpComm :
    public NONCOPYABLE,
    public IoIpReceiver
{
public:
    class InputFilter {
    public:
    InputFilter(IoIpManager&    io_ip_manager,
            const string&   receiver_name,
            uint8_t     ip_protocol)
        : _io_ip_manager(io_ip_manager),
          _receiver_name(receiver_name),
          _ip_protocol(ip_protocol)
    {}
    virtual ~InputFilter() {}

    IoIpManager& io_ip_manager() { return (_io_ip_manager); }

    const IoIpManager& io_ip_manager() const { return (_io_ip_manager); }

    const string& receiver_name() const { return (_receiver_name); }

    uint8_t ip_protocol() const { return (_ip_protocol); }

    virtual void recv(const struct IPvXHeaderInfo& header,
              const vector<uint8_t>& payload) = 0;

    virtual void recv_system_multicast_upcall(const vector<uint8_t>& payload) = 0;

    virtual void bye() = 0;

    private:
    IoIpManager&    _io_ip_manager;
    string      _receiver_name;
    uint8_t     _ip_protocol;
    };

    class JoinedMulticastGroup {
    public:
    JoinedMulticastGroup(const string& if_name, const string& vif_name,
                 const IPvX& group_address)
        : _if_name(if_name),
          _vif_name(vif_name),
          _group_address(group_address)
    {}
#ifdef XORP_USE_USTL
    JoinedMulticastGroup() { }
#endif
    virtual ~JoinedMulticastGroup() {}

    const string& if_name() const { return _if_name; }
    const string& vif_name() const { return _vif_name; }
    const IPvX& group_address() const { return _group_address; }

    bool operator<(const JoinedMulticastGroup& other) const {
        if (_if_name != other._if_name)
        return (_if_name < other._if_name);
        if (_vif_name != other._vif_name)
        return (_vif_name < other._vif_name);
        return (_group_address < other._group_address);
    }

    bool operator==(const JoinedMulticastGroup& other) const {
        return ((_if_name == other._if_name) &&
            (_vif_name == other._vif_name) &&
            (_group_address == other._group_address));
    }

    void add_receiver(const string& receiver_name) {
        _receivers.insert(receiver_name);
    }

    void delete_receiver(const string& receiver_name) {
        _receivers.erase(receiver_name);
    }

    bool empty() const { return _receivers.empty(); }

    set<string>& get_receivers() { return _receivers; }

    private:
    string      _if_name;
    string      _vif_name;
    IPvX        _group_address;
    set<string> _receivers;
    };

public:
    IoIpComm(IoIpManager& io_ip_manager, const IfTree& iftree, int family,
         uint8_t ip_protocol);

    virtual ~IoIpComm();

    void allocate_io_ip_plugins();

    void deallocate_io_ip_plugins();

    void allocate_io_ip_plugin(FeaDataPlaneManager* fea_data_plane_manager);

    void deallocate_io_ip_plugin(FeaDataPlaneManager* fea_data_plane_manager);

    void start_io_ip_plugins();

    void stop_io_ip_plugins();

    int add_filter(InputFilter* filter);

    int remove_filter(InputFilter* filter);

    bool no_input_filters() const { return _input_filters.empty(); }

    int     send_packet(const string&   if_name,
                const string&   vif_name,
                const IPvX&     src_address,
                const IPvX&     dst_address,
                int32_t     ip_ttl,
                int32_t     ip_tos,
                bool        ip_router_alert,
                bool        ip_internet_control,
                const vector<uint8_t>& ext_headers_type,
                const vector<vector<uint8_t> >& ext_headers_payload,
                const vector<uint8_t>& payload,
                string&     error_msg);

    virtual void recv_packet(const string&  if_name,
                 const string&  vif_name,
                 const IPvX&    src_address,
                 const IPvX&    dst_address,
                 int32_t        ip_ttl,
                 int32_t        ip_tos,
                 bool       ip_router_alert,
                 bool       ip_internet_control,
                 const vector<uint8_t>& ext_headers_type,
                 const vector<vector<uint8_t> >& ext_headers_payload,
                 const vector<uint8_t>& payload);

    virtual void recv_system_multicast_upcall(const vector<uint8_t>& payload);

    int     join_multicast_group(const string&  if_name,
                     const string&  vif_name,
                     const IPvX&    group_address,
                     const string&  receiver_name,
                     string&        error_msg);

    int     leave_multicast_group(const string& if_name,
                      const string& vif_name,
                      const IPvX&   group_address,
                      const string& receiver_name,
                      string&       error_msg);

    int leave_all_multicast_groups(const string& if_name,
                  const string& vif_name,
                  string& error_msg);

    uint8_t ip_protocol() const { return (_ip_protocol); }

    XorpFd first_valid_mcast_protocol_fd_in();

private:
    IoIpComm(const IoIpComm&);          // Not implemented.
    IoIpComm& operator=(const IoIpComm&);   // Not implemented.

    IoIpManager&        _io_ip_manager;
    const IfTree&       _iftree;
    const int           _family;
    const uint8_t       _ip_protocol;

    typedef list<pair<FeaDataPlaneManager*, IoIp*> >IoIpPlugins;
    IoIpPlugins         _io_ip_plugins;

    list<InputFilter*>      _input_filters;
    typedef map<JoinedMulticastGroup, JoinedMulticastGroup> JoinedGroupsTable;
    JoinedGroupsTable       _joined_groups_table;
};

class IoIpManagerReceiver {
public:
    virtual ~IoIpManagerReceiver() {}

    virtual void recv_event(const string&           receiver_name,
                const struct IPvXHeaderInfo&    header,
                const vector<uint8_t>&      payload) = 0;
};

class IoIpManager : public IoIpManagerReceiver,
            public InstanceWatcher {
public:
    typedef XorpCallback2<int, const uint8_t*, size_t>::RefPtr UpcallReceiverCb;

    IoIpManager(FeaNode& fea_node, const IfTree& iftree);

    virtual ~IoIpManager();

    int send(const string&  if_name,
         const string&  vif_name,
         const IPvX&    src_address,
         const IPvX&    dst_address,
         uint8_t        ip_protocol,
         int32_t        ip_ttl,
         int32_t        ip_tos,
         bool       ip_router_alert,
         bool       ip_internet_control,
         const vector<uint8_t>& ext_headers_type,
         const vector<vector<uint8_t> >& ext_headers_payload,
         const vector<uint8_t>& payload,
         string&        error_msg);

    int register_receiver(int       family,
              const string& receiver_name,
              const string& if_name,
              const string& vif_name,
              uint8_t   ip_protocol,
              bool      enable_multicast_loopback,
              string&   error_msg);
    
    int unregister_receiver(int         family,
                const string&   receiver_name,
                const string&   if_name,
                const string&   vif_name,
                uint8_t     ip_protocol,
                string&     error_msg);

    int join_multicast_group(const string&  receiver_name,
                 const string&  if_name,
                 const string&  vif_name,
                 uint8_t        ip_protocol,
                 const IPvX&    group_address,
                 string&        error_msg);

    int leave_multicast_group(const string& receiver_name,
                  const string& if_name,
                  const string& vif_name,
                  uint8_t       ip_protocol,
                  const IPvX&   group_address,
                  string&       error_msg);

    int leave_all_multicast_groups(const string& if_name,
                   const string& vif_name,
                   string& error_msg);

    int register_system_multicast_upcall_receiver(int       family,
                          uint8_t   ip_protocol,
                          IoIpManager::UpcallReceiverCb receiver_cb,
                          XorpFd&   mcast_receiver_fd,
                          string&   error_msg);

    int unregister_system_multicast_upcall_receiver(int     family,
                            uint8_t ip_protocol,
                            string& error_msg);

    void recv_event(const string&           receiver_name,
            const struct IPvXHeaderInfo&    header,
            const vector<uint8_t>&      payload);

    void instance_birth(const string& instance_name);

    void instance_death(const string& instance_name);

    void set_io_ip_manager_receiver(IoIpManagerReceiver* v) {
    _io_ip_manager_receiver = v;
    }

    const IfTree&   iftree() const { return _iftree; }

    int register_data_plane_manager(FeaDataPlaneManager* fea_data_plane_manager,
                    bool is_exclusive);

    int unregister_data_plane_manager(FeaDataPlaneManager* fea_data_plane_manager);

    list<FeaDataPlaneManager*>& fea_data_plane_managers() {
    return _fea_data_plane_managers;
    }

private:
    typedef map<uint8_t, IoIpComm*> CommTable;
    typedef multimap<string, IoIpComm::InputFilter*> FilterBag;

    CommTable& comm_table_by_family(int family);

    FilterBag& filters_by_family(int family);

    void erase_filters_by_receiver_name(int family,
                    const string& receiver_name);

    bool has_filter_by_receiver_name(const string& receiver_name) const;

    void erase_filters(CommTable& comm_table, FilterBag& filters,
               const FilterBag::iterator& begin,
               const FilterBag::iterator& end);

    FeaNode&        _fea_node;
    EventLoop&      _eventloop;
    const IfTree&   _iftree;

    // Collection of IP communication handlers keyed by protocol.
    CommTable       _comm_table4;
    CommTable       _comm_table6;

    // Collection of input filters created by IoIpManager
    FilterBag       _filters4;
    FilterBag       _filters6;

    IoIpManagerReceiver* _io_ip_manager_receiver;

    list<FeaDataPlaneManager*> _fea_data_plane_managers;
};

#endif // __FEA_IO_IP_MANAGER_HH__