cfg_iface.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 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 CFG_IFACE_H
#define CFG_IFACE_H
 
#include <asiolink/io_address.h>
#include <dhcp/iface_mgr.h>
#include <util/reconnect_ctl.h>
#include <cc/cfg_to_element.h>
#include <cc/user_context.h>
#include <boost/shared_ptr.hpp>
#include <map>
#include <set>
#include <string>
 
namespace isc {
namespace dhcp {
 
class DuplicateIfaceName : public Exception {
public:
    DuplicateIfaceName(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class InvalidIfaceName : public Exception {
public:
    InvalidIfaceName(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class NoSuchIface : public Exception {
public:
    NoSuchIface(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class DuplicateAddress : public Exception {
public:
    DuplicateAddress(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class NoSuchAddress : public Exception {
public:
    NoSuchAddress(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class InvalidSocketType : public Exception {
public:
    InvalidSocketType(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class CfgIface : public isc::data::UserContext, public isc::data::CfgToElement {
public:
 
    enum SocketType  {
        SOCKET_RAW,
        SOCKET_UDP
    };
 
    enum OutboundIface {
        SAME_AS_INBOUND,
        USE_ROUTING
    };
 
    static const char* ALL_IFACES_KEYWORD;
 
    CfgIface();
 
    void closeSockets() const;
 
    bool equals(const CfgIface& other) const;
 
    void openSockets(const uint16_t family, const uint16_t port,
                     const bool use_bcast = true);
 
    void reset();
 
    void use(const uint16_t family, const std::string& iface_name);
 
    void useSocketType(const uint16_t family, const SocketType& socket_type);
 
    void useSocketType(const uint16_t family,
                       const std::string& socket_type_name);
 
    SocketType getSocketType() const {
        return (socket_type_);
    }
 
    std::string socketTypeToText() const;
 
    void setOutboundIface(const OutboundIface& outbound_iface);
 
    OutboundIface getOutboundIface() const;
 
    std::string outboundTypeToText() const;
 
    static OutboundIface textToOutboundIface(const std::string& txt);
 
    SocketType textToSocketType(const std::string& socket_type_name) const;
 
    bool operator==(const CfgIface& other) const {
        return (equals(other));
    }
 
    bool operator!=(const CfgIface& other) const {
        return (!equals(other));
    }
 
    virtual isc::data::ElementPtr toElement() const;
 
    void setReDetect(bool re_detect) {
        re_detect_ = re_detect;
    }
 
    void setServiceSocketsRequireAll(bool require_all) {
        service_socket_require_all_ = require_all;
    }
 
    bool getServiceSocketsRequireAll() const {
        return (service_socket_require_all_);
    }
 
    void setServiceSocketsRetryWaitTime(uint32_t interval) {
        service_sockets_retry_wait_time_ = interval;
    }
 
    uint32_t getServiceSocketsRetryWaitTime() const {
        return (service_sockets_retry_wait_time_);
    }
 
    void setServiceSocketsMaxRetries(uint32_t max_retries) {
        service_sockets_max_retries_ = max_retries;
    }
 
    uint32_t getServiceSocketsMaxRetries() const {
        return (service_sockets_max_retries_);
    }
 
    util::ReconnectCtlPtr getReconnectCtl() const {
        return (reconnect_ctl_);
    }
 
    typedef std::function<void(util::ReconnectCtlPtr)> OpenSocketsFailedCallback;
 
    static OpenSocketsFailedCallback open_sockets_failed_callback_;
 
private:
 
    static bool multipleAddressesPerInterfaceActive();
 
    void setState(const uint16_t family, const bool inactive,
                  const bool loopback_inactive) const;
 
    void setIfaceAddrsState(const uint16_t family, const bool active,
                            Iface& iface) const;
 
    static void socketOpenErrorHandler(const std::string& errmsg);
 
    static std::pair<bool, bool> openSocketsForFamily(const uint16_t family,
                                                      const uint16_t port,
                                                      const bool can_use_bcast,
                                                      const bool skip_opened);
 
    util::ReconnectCtlPtr makeReconnectCtl() const;
 
    static bool openSocketsWithRetry(util::ReconnectCtlPtr reconnect_ctl,
                                     const uint16_t family, const uint16_t port,
                                     const bool can_use_bcast);
 
    typedef std::set<std::string> IfaceSet;
 
    IfaceSet iface_set_;
 
    typedef std::multimap<std::string, asiolink::IOAddress> ExplicitAddressMap;
 
    ExplicitAddressMap address_map_;
 
    bool wildcard_used_;
 
    SocketType socket_type_;
 
    bool re_detect_;
 
    bool service_socket_require_all_;
 
    uint32_t service_sockets_retry_wait_time_;
 
    uint32_t service_sockets_max_retries_;
 
    OutboundIface outbound_iface_;
 
    util::ReconnectCtlPtr reconnect_ctl_;
};
 
typedef boost::shared_ptr<CfgIface> CfgIfacePtr;
 
typedef boost::shared_ptr<const CfgIface> ConstCfgIfacePtr;
 
}
}
 
#endif // CFG_IFACE_H