client_class_def.h

Go to the documentation of this file.

// Copyright (C) 2015-2023 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 CLIENT_CLASS_DEF_H
#define CLIENT_CLASS_DEF_H
 
#include <cc/cfg_to_element.h>
#include <cc/stamped_element.h>
#include <cc/user_context.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/cfg_option_def.h>
#include <eval/token.h>
#include <exceptions/exceptions.h>
#include <util/triplet.h>
#include <util/optional.h>
 
#include <string>
#include <unordered_map>
#include <list>
#include <vector>
 
namespace isc {
namespace dhcp {
 
class DuplicateClientClassDef : public isc::Exception {
public:
    DuplicateClientClassDef(const char* file, size_t line, const char* what)
        : isc::Exception(file, line, what) {}
};
 
class ClientClassDef : public data::UserContext,
                       public data::CfgToElement,
                       public data::StampedElement {
public:
    ClientClassDef(const std::string& name, const ExpressionPtr& match_expr,
                   const CfgOptionPtr& options = CfgOptionPtr());
 
    ClientClassDef(const ClientClassDef& rhs);
 
    virtual ~ClientClassDef();
 
    std::string getName() const;
 
    void setName(const std::string& name);
 
    const ExpressionPtr& getMatchExpr() const;
 
    void setMatchExpr(const ExpressionPtr& match_expr);
 
    std::string getTest() const;
 
    void setTest(const std::string& test);
 
    bool getRequired() const;
 
    void setRequired(bool required);
 
    bool getDependOnKnown() const;
 
    void setDependOnKnown(bool depend_on_known);
 
    const CfgOptionDefPtr& getCfgOptionDef() const;
 
    void setCfgOptionDef(const CfgOptionDefPtr& cfg_option_def);
 
    const CfgOptionPtr& getCfgOption() const;
 
    void setCfgOption(const CfgOptionPtr& cfg_option);
 
    bool dependOnClass(const std::string& name) const;
 
    bool equals(const ClientClassDef& other) const;
 
    bool operator==(const ClientClassDef& other) const {
        return (equals(other));
    }
 
    bool operator!=(const ClientClassDef& other) const {
        return (!(equals(other)));
    }
 
    friend std::ostream& operator<<(std::ostream& os, const ClientClassDef& x);
 
    const asiolink::IOAddress& getNextServer() const {
        return (next_server_);
    }
 
    void setNextServer(const asiolink::IOAddress& addr) {
        next_server_ = addr;
    }
 
    void setSname(const std::string& sname) {
        sname_ = sname;
    }
 
    const std::string& getSname() const {
        return (sname_);
    }
 
    void setFilename(const std::string& filename) {
        filename_ = filename;
    }
 
    const std::string& getFilename() const {
        return (filename_);
    }
 
    util::Triplet<uint32_t> getValid() const {
        return (valid_);
    }
 
    void setValid(const util::Triplet<uint32_t>& valid) {
        valid_ = valid;
    }
 
    util::Triplet<uint32_t> getPreferred() const {
        return (preferred_);
    }
 
    void setPreferred(const util::Triplet<uint32_t>& preferred) {
        preferred_ = preferred;
    }
 
    void setOfferLft(const util::Optional<uint32_t>& offer_lft) {
        offer_lft_ = offer_lft;
    }
 
    util::Optional<uint32_t> getOfferLft() const {
        return (offer_lft_);
    }
 
    virtual void test(PktPtr pkt, const ExpressionPtr& expr_ptr);
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
    std::string name_;
 
    ExpressionPtr match_expr_;
 
    std::string test_;
 
    bool required_;
 
    bool depend_on_known_;
 
    CfgOptionDefPtr cfg_option_def_;
 
    CfgOptionPtr cfg_option_;
 
    asiolink::IOAddress next_server_;
 
    std::string sname_;
 
    std::string filename_;
 
    util::Triplet<uint32_t> valid_;
 
    util::Triplet<uint32_t> preferred_;
 
    util::Optional<uint32_t> offer_lft_;
};
 
class TemplateClientClassDef : public ClientClassDef {
public:
    TemplateClientClassDef(const std::string& name, const ExpressionPtr& match_expr,
                           const CfgOptionPtr& options = CfgOptionPtr());
 
    virtual void test(PktPtr pkt, const ExpressionPtr& expr_ptr) override;
 
    virtual isc::data::ElementPtr toElement() const override;
 
    static const std::string SPAWN_CLASS_PREFIX;
};
 
typedef boost::shared_ptr<ClientClassDef> ClientClassDefPtr;
 
typedef std::unordered_map<std::string, ClientClassDefPtr> ClientClassDefMap;
 
typedef boost::shared_ptr<ClientClassDefMap> ClientClassDefMapPtr;
 
typedef std::vector<ClientClassDefPtr> ClientClassDefList;
 
typedef boost::shared_ptr<ClientClassDefList> ClientClassDefListPtr;
 
class ClientClassDictionary : public isc::data::CfgToElement {
 
public:
    ClientClassDictionary();
 
    ClientClassDictionary(const ClientClassDictionary& rhs);
 
    ~ClientClassDictionary();
 
    void addClass(const std::string& name, const ExpressionPtr& match_expr,
                  const std::string& test, bool required, bool depend_on_known,
                  const CfgOptionPtr& options,
                  CfgOptionDefPtr defs = CfgOptionDefPtr(),
                  isc::data::ConstElementPtr user_context = isc::data::ConstElementPtr(),
                  asiolink::IOAddress next_server = asiolink::IOAddress("0.0.0.0"),
                  const std::string& sname = std::string(),
                  const std::string& filename = std::string(),
                  const util::Triplet<uint32_t>& valid = util::Triplet<uint32_t>(),
                  const util::Triplet<uint32_t>& preferred = util::Triplet<uint32_t>(),
                  bool is_template = false,
                  const util::Optional<uint32_t>& offer_lft = util::Optional<uint32_t>());
 
    void addClass(ClientClassDefPtr& class_def);
 
    ClientClassDefPtr findClass(const std::string& name) const;
 
    void removeClass(const std::string& name);
 
    void removeClass(const uint64_t id);
 
    const ClientClassDefListPtr& getClasses() const;
 
    bool empty() const;
 
    bool dependOnClass(const std::string& name, std::string& dependent_class) const;
 
    bool equals(const ClientClassDictionary& other) const;
 
    void initMatchExpr(uint16_t family);
 
    void createOptions(const CfgOptionDefPtr& cfg_option_def);
 
    bool operator==(const ClientClassDictionary& other) const {
        return (equals(other));
    }
 
    bool operator!=(const ClientClassDictionary& other) const {
        return (!equals(other));
    }
 
    ClientClassDictionary& operator=(const ClientClassDictionary& rhs);
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
 
    ClientClassDefMapPtr map_;
 
    ClientClassDefListPtr list_;
};
 
typedef boost::shared_ptr<ClientClassDictionary> ClientClassDictionaryPtr;
 
extern std::list<std::string> builtinNames;
 
extern std::list<std::string> builtinPrefixes;
 
bool isClientClassBuiltIn(const ClientClass& client_class);
 
bool isClientClassDefined(ClientClassDictionaryPtr& class_dictionary,
                          bool& depend_on_known,
                          const ClientClass& client_class);
 
} // namespace isc::dhcp
} // namespace isc
 
#endif // CLIENT_CLASS_DEF_H