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