network.h

Go to the documentation of this file.

// Copyright (C) 2017-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 NETWORK_H
#define NETWORK_H
 
#include <asiolink/io_address.h>
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <cc/stamped_element.h>
#include <cc/user_context.h>
#include <dhcp/classify.h>
#include <dhcp/option.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/cfg_4o6.h>
#include <dhcpsrv/triplet.h>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <cstdint>
#include <string>
 
namespace isc {
namespace dhcp {
 
typedef std::vector<isc::asiolink::IOAddress> IOAddressList;
 
class Network : public virtual isc::data::StampedElement,
                public virtual isc::data::UserContext,
                public isc::data::CfgToElement {
public:
    class RelayInfo {
    public:
 
        void addAddress(const asiolink::IOAddress& addr);
 
        const IOAddressList& getAddresses() const;
 
        bool hasAddresses() const;
 
        bool containsAddress(const asiolink::IOAddress& addr) const;
 
    private:
        IOAddressList addresses_;
    };
 
 
    typedef enum  {
 
        HR_DISABLED,
 
        HR_OUT_OF_POOL,
 
        HR_GLOBAL,
 
        HR_ALL
    } HRMode;
 
    typedef boost::shared_ptr<Network::RelayInfo> RelayInfoPtr;
 
    Network()
        : iface_name_(), client_class_(""), t1_(), t2_(), valid_(),
          host_reservation_mode_(HR_ALL), cfg_option_(new CfgOption()) {
    }
 
    virtual ~Network() { };
 
    void setIface(const std::string& iface_name) {
        iface_name_ = iface_name;
    }
 
    std::string getIface() const {
        return (iface_name_);
    };
 
    void setRelayInfo(const RelayInfo& relay) {
        relay_ = relay;
    }
 
    const RelayInfo& getRelayInfo() const {
        return (relay_);
    }
 
    void addRelayAddress(const asiolink::IOAddress& addr);
 
    const IOAddressList& getRelayAddresses() const;
 
    bool hasRelays() const;
 
    bool hasRelayAddress(const asiolink::IOAddress& address) const;
 
    virtual bool
    clientSupported(const isc::dhcp::ClientClasses& client_classes) const;
 
    void allowClientClass(const isc::dhcp::ClientClass& class_name);
 
    void requireClientClass(const isc::dhcp::ClientClass& class_name);
 
    const isc::dhcp::ClientClasses& getRequiredClasses() const;
 
    const isc::dhcp::ClientClass& getClientClass() const {
        return (client_class_);
    }
 
    Triplet<uint32_t> getValid() const {
        return (valid_);
    }
 
    void setValid(const Triplet<uint32_t>& valid) {
        valid_ = valid;
    }
 
    Triplet<uint32_t> getT1() const {
        return (t1_);
    }
 
    void setT1(const Triplet<uint32_t>& t1) {
        t1_ = t1;
    }
 
    Triplet<uint32_t> getT2() const {
        return (t2_);
    }
 
    void setT2(const Triplet<uint32_t>& t2) {
        t2_ = t2;
    }
 
    HRMode
    getHostReservationMode() const {
        return (host_reservation_mode_);
    }
 
    void setHostReservationMode(HRMode mode) {
        host_reservation_mode_ = mode;
    }
 
    CfgOptionPtr getCfgOption() {
        return (cfg_option_);
    }
 
    ConstCfgOptionPtr getCfgOption() const {
        return (cfg_option_);
    }
 
    virtual data::ElementPtr toElement() const;
 
protected:
 
    std::string iface_name_;
 
    RelayInfo relay_;
 
    ClientClass client_class_;
 
    ClientClasses required_classes_;
 
    Triplet<uint32_t> t1_;
 
    Triplet<uint32_t> t2_;
 
    Triplet<uint32_t> valid_;
 
    HRMode host_reservation_mode_;
 
    CfgOptionPtr cfg_option_;
};
 
typedef boost::shared_ptr<Network> NetworkPtr;
 
typedef boost::weak_ptr<Network> WeakNetworkPtr;
 
class Network4 : public Network {
public:
 
    Network4()
        : Network(), match_client_id_(true), authoritative_(false) {
    }
 
    bool getMatchClientId() const {
        return (match_client_id_);
    }
 
    void setMatchClientId(const bool match) {
        match_client_id_ = match;
    }
 
    bool getAuthoritative() const {
        return (authoritative_);
    }
 
    void setAuthoritative(const bool authoritative) {
        authoritative_ = authoritative;
    }
 
    virtual data::ElementPtr toElement() const;
 
    virtual asiolink::IOAddress getServerId() const;
 
private:
 
    bool match_client_id_;
 
    bool authoritative_;
};
 
class Network6 : public Network {
public:
 
    Network6()
        : Network(), preferred_(0), interface_id_(), rapid_commit_(false) {
    }
 
    Triplet<uint32_t> getPreferred() const {
        return (preferred_);
    }
 
    void setPreferred(const Triplet<uint32_t>& preferred) {
        preferred_ = preferred;
    }
 
    OptionPtr getInterfaceId() const {
        return (interface_id_);
    }
 
    void setInterfaceId(const OptionPtr& ifaceid) {
        interface_id_ = ifaceid;
    }
 
    bool getRapidCommit() const {
        return (rapid_commit_);
    }
 
    void setRapidCommit(const bool rapid_commit) {
        rapid_commit_ = rapid_commit;
    };
 
    virtual data::ElementPtr toElement() const;
 
private:
 
    Triplet<uint32_t> preferred_;
 
    OptionPtr interface_id_;
 
    bool rapid_commit_;
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // NETWORK_H