iface_mgr.h

Go to the documentation of this file.

// Copyright (C) 2011-2023 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef IFACE_MGR_H
#define IFACE_MGR_H
 
#include <asiolink/io_address.h>
#include <dhcp/dhcp4.h>
#include <dhcp/dhcp6.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <dhcp/packet_queue_mgr4.h>
#include <dhcp/packet_queue_mgr6.h>
#include <dhcp/pkt_filter.h>
#include <dhcp/pkt_filter6.h>
#include <util/optional.h>
#include <util/watch_socket.h>
#include <util/watched_thread.h>
 
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/noncopyable.hpp>
#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
 
#include <functional>
#include <list>
#include <vector>
#include <mutex>
 
namespace isc {
 
namespace dhcp {
 
class IfaceDetectError : public Exception {
public:
    IfaceDetectError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class PacketFilterChangeDenied : public Exception {
public:
    PacketFilterChangeDenied(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class SignalInterruptOnSelect : public Exception {
public:
    SignalInterruptOnSelect(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class SocketConfigError : public Exception {
public:
    SocketConfigError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class SocketReadError : public Exception {
public:
    SocketReadError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class SocketWriteError : public Exception {
public:
    SocketWriteError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class IfaceNotFound : public Exception {
public:
    IfaceNotFound(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class SocketNotFound : public Exception {
public:
    SocketNotFound(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class Iface : public boost::noncopyable {
public:
 
    static const unsigned int MAX_MAC_LEN = 20;
 
    typedef util::Optional<asiolink::IOAddress> Address;
 
    typedef std::list<Address> AddressCollection;
 
    typedef std::list<SocketInfo> SocketCollection;
 
    using ErrorBuffer = std::vector<std::string>;
 
    Iface(const std::string& name, unsigned int ifindex);
 
    ~Iface() { }
 
    void closeSockets();
 
    void closeSockets(const uint16_t family);
 
    std::string getFullName() const;
 
    std::string getPlainMac() const;
 
    void setMac(const uint8_t* mac, size_t macLen);
 
    size_t getMacLen() const { return mac_len_; }
 
    const uint8_t* getMac() const { return mac_; }
 
    void setFlags(uint64_t flags);
 
    unsigned int getIndex() const { return ifindex_; }
 
    std::string getName() const { return name_; };
 
    void setHWType(uint16_t type ) { hardware_type_ = type; }
 
    uint16_t getHWType() const { return hardware_type_; }
 
    const AddressCollection& getAddresses() const { return addrs_; }
 
    bool getAddress4(isc::asiolink::IOAddress& address) const;
 
    bool hasAddress(const isc::asiolink::IOAddress& address) const;
 
    void addAddress(const isc::asiolink::IOAddress& addr);
 
    void setActive(const isc::asiolink::IOAddress& address, const bool active);
 
    void setActive(const bool active);
 
    unsigned int countActive4() const;
 
    bool delAddress(const isc::asiolink::IOAddress& addr);
 
    void addSocket(const SocketInfo& sock) {
        sockets_.push_back(sock);
    }
 
    bool delSocket(uint16_t sockfd);
 
    const SocketCollection& getSockets() const { return sockets_; }
 
    void clearUnicasts() {
        unicasts_.clear();
    }
 
    void addUnicast(const isc::asiolink::IOAddress& addr);
 
    const AddressCollection& getUnicasts() const {
        return unicasts_;
    }
 
    uint8_t* getReadBuffer() {
        if (read_buffer_.empty()) {
            return (0);
        }
        return (&read_buffer_[0]);
    }
 
    size_t getReadBufferSize() const {
        return (read_buffer_.size());
    }
 
    void resizeReadBuffer(const size_t new_size) {
        read_buffer_.resize(new_size);
    }
 
    void addError(std::string const& message);
 
    void clearErrors();
 
    ErrorBuffer const& getErrors() const;
 
protected:
    SocketCollection sockets_;
 
    std::string name_;
 
    unsigned int ifindex_;
 
    AddressCollection addrs_;
 
    AddressCollection unicasts_;
 
    uint8_t mac_[MAX_MAC_LEN];
 
    size_t mac_len_;
 
    uint16_t hardware_type_;
 
public:
 
    bool flag_loopback_;
 
    bool flag_up_;
 
    bool flag_running_;
 
    bool flag_multicast_;
 
    bool flag_broadcast_;
 
    uint64_t flags_;
 
    bool inactive4_;
 
    bool inactive6_;
 
private:
 
    std::vector<uint8_t> read_buffer_;
 
    ErrorBuffer errors_;
};
 
typedef boost::shared_ptr<Iface> IfacePtr;
 
class IfaceCollection {
public:
 
    typedef boost::multi_index_container<
        // Container comprises elements of IfacePtr type.
        IfacePtr,
        // Here we start enumerating various indexes.
        boost::multi_index::indexed_by<
            // Sequenced index allows accessing elements in the same way
            // as elements in std::list. Sequenced is the index #0.
            boost::multi_index::sequenced<>,
            // Start definition of index #1.
            boost::multi_index::hashed_unique<
                // Use the interface index as the key.
                boost::multi_index::const_mem_fun<
                    Iface, unsigned int, &Iface::getIndex
                >
            >,
            // Start definition of index #2.
            boost::multi_index::hashed_unique<
                // Use the interface name as the key.
                boost::multi_index::const_mem_fun<
                    Iface, std::string, &Iface::getName
                >
            >
        >
    > IfaceContainer;
 
    IfaceContainer::const_iterator begin() const {
        return (ifaces_container_.begin());
    }
 
    IfaceContainer::const_iterator end() const {
        return (ifaces_container_.end());
    }
 
    bool empty() const {
        return (ifaces_container_.empty());
    }
 
    size_t size() const {
        return (ifaces_container_.size());
    }
 
    void clear() {
        cache_.reset();
        ifaces_container_.clear();
    }
 
    void push_back(const IfacePtr& iface) {
        ifaces_container_.push_back(iface);
    }
 
    IfacePtr getIface(const unsigned int ifindex);
 
    IfacePtr getIface(const std::string& ifname);
 
private:
    IfacePtr getIfaceInternal(const unsigned int ifindex, const bool need_lock);
 
    IfacePtr getIfaceInternal(const std::string& ifname, const bool need_lock);
 
    std::mutex mutex_;
 
    IfacePtr cache_;
 
    IfaceContainer ifaces_container_;
};
 
typedef boost::multi_index_container<
    asiolink::IOAddress,
    // Here we start enumerating the only index.
    boost::multi_index::indexed_by<
        // Start definition of index #0.
        boost::multi_index::hashed_unique<
            // Use the address in its network order integer form as the key.
            boost::multi_index::const_mem_fun<
                asiolink::IOAddress, uint32_t, &asiolink::IOAddress::toUint32
            >
        >
    >
> BoundAddresses;
 
class IfaceMgr;
 
typedef boost::shared_ptr<IfaceMgr> IfaceMgrPtr;
 
typedef
std::function<void(const std::string& errmsg)> IfaceMgrErrorMsgCallback;
 
class IfaceMgr : public boost::noncopyable {
public:
    typedef std::function<void (int fd)> SocketCallback;
 
    typedef std::function<bool (bool)> DetectCallback;
 
    struct SocketCallbackInfo {
        int socket_;
 
        SocketCallback callback_;
    };
 
    typedef std::list<SocketCallbackInfo> SocketCallbackInfoContainer;
 
    static const uint32_t RCVBUFSIZE = 1500;
 
    static IfaceMgr& instance();
 
    static const IfaceMgrPtr& instancePtr();
 
    virtual ~IfaceMgr();
 
    void setTestMode(const bool test_mode) {
        test_mode_ = test_mode;
    }
 
    bool isTestMode() const {
        return (test_mode_);
    }
 
    void setAllowLoopBack(const bool allow_loopback) {
        allow_loopback_ = allow_loopback;
    }
 
    bool isDirectResponseSupported() const;
 
    IfacePtr getIface(const unsigned int ifindex);
 
    IfacePtr getIface(const std::string& ifname);
 
    IfacePtr getIface(const PktPtr& pkt);
 
    const IfaceCollection& getIfaces() { return (ifaces_); }
 
    void clearIfaces();
 
    void setDetectCallback(const DetectCallback& cb) {
        detect_callback_ = cb;
    }
 
    bool checkDetectIfaces(bool update_only);
 
    void detectIfaces(bool update_only = false);
 
    void clearUnicasts();
 
    void clearBoundAddresses();
 
    void collectBoundAddresses();
 
    uint16_t getSocket(const isc::dhcp::Pkt6Ptr& pkt);
 
    SocketInfo getSocket(const isc::dhcp::Pkt4Ptr& pkt);
 
    void printIfaces(std::ostream& out = std::cout);
 
    bool send(const Pkt6Ptr& pkt);
 
    bool send(const Pkt4Ptr& pkt);
 
    Pkt6Ptr receive6(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    Pkt4Ptr receive4(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    int openSocket(const std::string& ifname,
                   const isc::asiolink::IOAddress& addr,
                   const uint16_t port,
                   const bool receive_bcast = false,
                   const bool send_bcast = false);
 
    int openSocketFromIface(const std::string& ifname,
                            const uint16_t port,
                            const uint8_t family);
 
    int openSocketFromAddress(const isc::asiolink::IOAddress& addr,
                              const uint16_t port);
 
    int openSocketFromRemoteAddress(const isc::asiolink::IOAddress& remote_addr,
                                    const uint16_t port);
 
    bool openSockets6(const uint16_t port = DHCP6_SERVER_PORT,
                      IfaceMgrErrorMsgCallback error_handler = 0,
                      const bool skip_opened = false);
 
    bool openSockets4(const uint16_t port = DHCP4_SERVER_PORT,
                      const bool use_bcast = true,
                      IfaceMgrErrorMsgCallback error_handler = 0,
                      const bool skip_opened = false);
 
    void closeSockets();
 
    uint16_t countIfaces() { return ifaces_.size(); }
 
    void addExternalSocket(int socketfd, SocketCallback callback);
 
    void deleteExternalSocket(int socketfd);
 
    int purgeBadSockets();
 
    void deleteAllExternalSockets();
 
    void setPacketFilter(const PktFilterPtr& packet_filter);
 
    void setPacketFilter(const PktFilter6Ptr& packet_filter);
 
    void setMatchingPacketFilter(const bool direct_response_desired = false);
 
    void addInterface(const IfacePtr& iface);
 
    bool hasOpenSocket(const uint16_t family) const;
 
    bool hasOpenSocket(const isc::asiolink::IOAddress& addr) const;
 
    PacketQueueMgr4Ptr getPacketQueueMgr4() {
        return (packet_queue_mgr4_);
    }
 
    PacketQueue4Ptr getPacketQueue4() {
        return (packet_queue_mgr4_->getPacketQueue());
    }
 
    PacketQueueMgr6Ptr getPacketQueueMgr6() {
        return (packet_queue_mgr6_);
    }
 
    PacketQueue6Ptr getPacketQueue6() {
        return (packet_queue_mgr6_->getPacketQueue());
    }
 
    void startDHCPReceiver(const uint16_t family);
 
    void stopDHCPReceiver();
 
    bool isDHCPReceiverRunning() const {
        return (dhcp_receiver_ != 0 && dhcp_receiver_->isRunning());
    }
 
    bool configureDHCPPacketQueue(const uint16_t family,
                                  data::ConstElementPtr queue_control);
 
    static void addFDtoSet(int fd, int& maxfd, fd_set* sockets);
 
    // don't use private, we need derived classes in tests
protected:
 
    IfaceMgr();
 
    int openSocket4(Iface& iface, const isc::asiolink::IOAddress& addr,
                    const uint16_t port, const bool receive_bcast = false,
                    const bool send_bcast = false);
 
    Pkt4Ptr receive4Direct(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    Pkt4Ptr receive4Indirect(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    int openSocket6(Iface& iface, const isc::asiolink::IOAddress& addr,
                    uint16_t port, const bool join_multicast);
 
    Pkt6Ptr receive6Direct(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    Pkt6Ptr receive6Indirect(uint32_t timeout_sec, uint32_t timeout_usec = 0);
 
    IfaceCollection ifaces_;
 
    BoundAddresses bound_address_;
 
    // TODO: Also keep this interface on Iface once interface detection
    // is implemented. We may need it e.g. to close all sockets on
    // specific interface
    //int recvsock_; // TODO: should be fd_set eventually, but we have only
    //int sendsock_; // 2 sockets for now. Will do for until next release
 
    // We can't use the same socket, as receiving socket
    // is bound to multicast address. And we all know what happens
    // to people who try to use multicast as source address.
 
private:
    isc::asiolink::IOAddress
    getLocalAddress(const isc::asiolink::IOAddress& remote_addr,
                    const uint16_t port);
 
    bool openMulticastSocket(Iface& iface,
                             const isc::asiolink::IOAddress& addr,
                             const uint16_t port,
                             IfaceMgrErrorMsgCallback error_handler = 0);
 
    void receiveDHCP4Packets();
 
    void receiveDHCP4Packet(Iface& iface, const SocketInfo& socket_info);
 
    void receiveDHCP6Packets();
 
    void receiveDHCP6Packet(const SocketInfo& socket_info);
 
    void deleteExternalSocketInternal(int socketfd);
 
    PktFilterPtr packet_filter_;
 
    PktFilter6Ptr packet_filter6_;
 
    SocketCallbackInfoContainer callbacks_;
 
    std::mutex callbacks_mutex_;
 
    bool test_mode_;
 
    DetectCallback detect_callback_;
 
    bool allow_loopback_;
 
    PacketQueueMgr4Ptr packet_queue_mgr4_;
 
    PacketQueueMgr6Ptr packet_queue_mgr6_;
 
    isc::util::WatchedThreadPtr dhcp_receiver_;
};
 
}  // namespace isc::dhcp
}  // namespace isc
 
#endif // IFACE_MGR_H