client_class_def.h

Go to the documentation of this file.

// Copyright (C) 2015-2022 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 <util/triplet.h>
#include <eval/token.h>
#include <exceptions/exceptions.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;
    }

    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_;
};

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);

    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