iface_mgr.h

Go to the documentation of this file.

// Copyright (C) 2011-2026 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/fd_event_handler_factory.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/member.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 <atomic>
#include <functional>
#include <list>
#include <mutex>
#include <thread>
#include <vector>
 
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 SocketFDError : public Exception {
public:
    SocketFDError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

class ReceiveTerminate : public Exception {
public:
    ReceiveTerminate(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

class Iface : public isc::data::CfgToElement, public boost::noncopyable {
public:

    static const unsigned int MAX_MAC_LEN = 20;

    typedef util::Optional<asiolink::IOAddress> Address;

    typedef std::list<Address> AddressCollection;

    typedef boost::multi_index_container<
        // Container comprises elements of SocketInfo type.
        SocketInfo,
        // Here we start enumerating various indexes.
        boost::multi_index::indexed_by<
            // Sequenced index #0 in insertion order.
            boost::multi_index::sequenced<>,
            // Sequenced index #1 in Least Recently Used order.
            boost::multi_index::sequenced<>
        >
    > SocketCollection;

    typedef SocketCollection::nth_index<1>::type SocketLruIndex;

    typedef SocketLruIndex::iterator SocketLruIterator;

    using ErrorBuffer = std::vector<std::string>;

    Iface(const std::string& name, unsigned int ifindex);

    ~Iface() = default;

    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_);
    }

    SocketCollection& getSocketsRef() {
        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;

    virtual isc::data::ElementPtr toElement() 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
                >
            >,
            // Start definition of index #3.
            // Sequence in Least Recently Used order.
            boost::multi_index::sequenced<>
        >
    > IfaceContainer;

    IfaceContainer::const_iterator begin() const {
        return (ifaces_container_.begin());
    }

    IfaceContainer::const_iterator end() const {
        return (ifaces_container_.end());
    }

    typedef IfaceContainer::nth_index<3>::type LruIndex;

    LruIndex& getLru() {
        return (ifaces_container_.get<3>());
    }

    typedef LruIndex::iterator LruIterator;

    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_;

        bool unusable_;

        SocketCallbackInfo(int socket)
            : socket_(socket), callback_(0), unusable_(false) {
        }
    };

    typedef boost::multi_index_container<
        // Container comprises elements of SocketCallbackInfo type.
        SocketCallbackInfo,
        // 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<>,
            // Use the file descriptor as the key for index #1.
            boost::multi_index::hashed_unique<
                boost::multi_index::member<
                    SocketCallbackInfo, int, &SocketCallbackInfo::socket_
                >
            >
        >
    > SocketCallbackInfoContainer;

    typedef SocketCallbackInfoContainer::iterator SocketCallbackInfoIterator;

    static const uint32_t RCVBUFSIZE = 1500;

    static IfaceMgr& instance();

    static const IfaceMgrPtr& instancePtr();

    virtual ~IfaceMgr();

    void initializeFDEventHandler();

    void setTestMode(const bool test_mode) {
        test_mode_ = test_mode;
    }

    bool isTestMode() const {
        return (test_mode_);
    }

    bool getCheckThreadId() const {
        return (check_thread_id_);
    }

    void setCheckThreadId(const bool check) {
        check_thread_id_ = check;
    }

    bool isMainThread() const {
        return (std::this_thread::get_id() == id_);
    }

    void setAllowLoopBack(const bool allow_loopback) {
        allow_loopback_ = allow_loopback;
    }

    bool isDirectResponseSupported() const;

    virtual bool isSocketReceivedTimeSupported() 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);

    bool isExternalSocket(int fd);

    bool isExternalSocketUnusable(int fd);

    void deleteExternalSocket(int socketfd);

    void deleteAllExternalSockets();

    std::list<int> getAllExternalSockets();

    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, bool unicast = false) 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 clear_queue = true);

    bool isDHCPReceiverRunning() const {
        return (dhcp_receiver_ != 0 && dhcp_receiver_->isRunning());
    }

    bool configureDHCPPacketQueue(const uint16_t family,
                                  data::ConstElementPtr queue_control);

    void setFamily(uint16_t family) {
        family_ = family == AF_INET ? AF_INET : AF_INET6;
    }

    uint16_t getFamily() const {
        return (family_);
    }

    isc::data::ElementPtr ifacesToElement() const;
 
    // 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);

    std::thread::id id_;

    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 scanReceiveDHCP4Packets();

    void receiveDHCP4Packet(Iface& iface, const SocketInfo& socket_info);

    void receiveDHCP6Packets();

    void scanReceiveDHCP6Packets();

    void receiveDHCP6Packet(const SocketInfo& socket_info);

    void deleteExternalSocketInternal(int socketfd);

    void handleClosedExternalSocket(SocketCallbackInfoIterator it);

    void handleClosedExternalSockets();

    void handleIfaceSocketError(const IfacePtr& iface, const SocketInfo& s);

    PktFilterPtr packet_filter_;

    PktFilter6Ptr packet_filter6_;

    SocketCallbackInfoContainer callbacks_;

    std::mutex callbacks_mutex_;

    bool test_mode_;

    std::atomic<bool> check_thread_id_;

    DetectCallback detect_callback_;

    bool allow_loopback_;

    PacketQueueMgr4Ptr packet_queue_mgr4_;

    PacketQueueMgr6Ptr packet_queue_mgr6_;

    isc::util::WatchedThreadPtr dhcp_receiver_;

    std::mutex receiver_mutex_;

    util::FDEventHandlerPtr fd_event_handler_;

    util::FDEventHandlerPtr receiver_fd_event_handler_;

    uint16_t family_;
};

class ReceiverCriticalSection : public boost::noncopyable {
public:

    ReceiverCriticalSection()
        : is_running_(IfaceMgr::instance().isDHCPReceiverRunning()) {
        if (is_running_) {
            IfaceMgr::instance().stopDHCPReceiver(false);
        }
    }

    ~ReceiverCriticalSection() {
        if (is_running_ && !IfaceMgr::instance().isDHCPReceiverRunning()) {
            auto family = IfaceMgr::instance().getFamily();
            IfaceMgr::instance().startDHCPReceiver(family);
        }
    }
 
private:
    bool is_running_;
};
 
}  // namespace isc::dhcp
}  // namespace isc
 
#endif // IFACE_MGR_H