iface_mgr.h

Go to the documentation of this file.

// Copyright (C) 2011-2018 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_value.h>
#include <util/watch_socket.h>
#include <util/threads/watched_thread.h>
 
#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
 
#include <list>
#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 Iface : public boost::noncopyable {
public:
 
    static const unsigned int MAX_MAC_LEN = 20;
 
    typedef util::OptionalValue<asiolink::IOAddress> Address;
 
    typedef std::list<Address> AddressCollection;
 
    typedef std::list<SocketInfo> SocketCollection;
 
    Iface(const std::string& name, 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);
 
    uint16_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 NULL;
        }
        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 IfaceMgr;
 
typedef boost::shared_ptr<IfaceMgr> IfaceMgrPtr;
 
typedef
boost::function<void(const std::string& errmsg)> IfaceMgrErrorMsgCallback;
 
class IfaceMgr : public boost::noncopyable {
public:
    typedef boost::function<void ()> SocketCallback;
 
    struct SocketCallbackInfo {
        int socket_;
 
        SocketCallback callback_;
    };
 
    typedef std::list<SocketCallbackInfo> SocketCallbackInfoContainer;
 
    static const uint32_t RCVBUFSIZE = 1500;
 
    // TODO performance improvement: we may change this into
    //      2 maps (ifindex-indexed and name-indexed) and
    //      also hide it (make it public make tests easier for now)
 
    typedef std::list<IfacePtr> IfaceCollection;
 
    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);
 
    const IfaceCollection& getIfaces() { return (ifaces_); }
 
    void clearIfaces();
 
    void detectIfaces();
 
    void clearUnicasts();
 
    uint16_t getSocket(const isc::dhcp::Pkt6& pkt);
 
    SocketInfo getSocket(const isc::dhcp::Pkt4& 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);
 
    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) {
        ifaces_.push_back(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();
 
    // TODO: having 2 maps (ifindex->iface and ifname->iface would)
    //      probably be better for performance reasons
 
    IfaceCollection ifaces_;
 
    // 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);
 
    PktFilterPtr packet_filter_;
 
    PktFilter6Ptr packet_filter6_;
 
    SocketCallbackInfoContainer callbacks_;
 
    bool test_mode_;
 
    bool allow_loopback_;
 
    PacketQueueMgr4Ptr packet_queue_mgr4_;
 
    PacketQueueMgr6Ptr packet_queue_mgr6_;
 
    isc::util::thread::WatchedThreadPtr dhcp_receiver_;
};
 
}; // namespace isc::dhcp
}; // namespace isc
 
#endif // IFACE_MGR_H