iface_mgr.h

Go to the documentation of this file.

// Copyright (C) 2011-2021 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;

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

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

protected:
    SocketCollection sockets_;

    std::string name_;

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

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, uint32_t, &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(uint32_t ifindex);

    IfacePtr getIface(const std::string& ifname);

private:
    IfacePtr getIfaceInternal(uint32_t ifindex, bool need_lock);

    IfacePtr getIfaceInternal(const std::string& ifname, 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;

    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(int ifindex);

    IfacePtr getIface(const std::string& ifname);

    IfacePtr getIface(const PktPtr& pkt);

    const IfaceCollection& getIfaces() { return (ifaces_); }

    void clearIfaces();

    void detectIfaces();

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

    bool openSockets4(const uint16_t port = DHCP4_SERVER_PORT,
                      const bool use_bcast = true,
                      IfaceMgrErrorMsgCallback error_handler = 0);

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


    void stubDetectIfaces();

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

    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