45            << expression_cfg->str() << 
"] must be a string, at (" 
   46            << expression_cfg->getPosition() << 
")");
 
   52    expression_cfg->getValue(value);
 
   56            << expression_cfg->getPosition() << 
")");
 
   65    } 
catch (
const std::exception& ex) {
 
   68                  "expression: [" << value
 
   69                  << 
"] error: " << ex.what() << 
" at (" 
   70                  << expression_cfg->getPosition() << 
")");
 
 
   80                            bool append_error_position,
 
   81                            bool check_dependencies) {
 
   83    std::string name = 
getString(class_def_cfg, 
"name");
 
   86                  "not empty parameter 'name' is required " 
   93    bool is_template = 
false;
 
   98    ConstElementPtr template_test_cfg = class_def_cfg->get(
"template-test");
 
   99    if (test_cfg && template_test_cfg) {
 
  101                  << test_cfg->getPosition() << 
") and (" 
  102                  << template_test_cfg->getPosition() << 
")");
 
  105    bool depend_on_known = 
false;
 
  107    if (template_test_cfg) {
 
  108        test_cfg = template_test_cfg;
 
  112        check_defined = [&class_dictionary, &depend_on_known, check_dependencies](
const ClientClass& cclass) {
 
  113            return (!check_dependencies || 
isClientClassDefined(class_dictionary, depend_on_known, cclass));
 
  119        parser.
parse(match_expr, test_cfg, family, check_defined, parser_type);
 
  120        test = test_cfg->stringValue();
 
  134        for (
auto const& option_def : option_defs->listValue()) {
 
  142                          "Not allowed option definition for code '" 
  143                          << def->getCode() << 
"' in space '" 
  144                          << def->getOptionSpaceName() << 
"' at (" 
  145                          << option_def->getPosition() << 
")");
 
  149            } 
catch (
const std::exception& ex) {
 
  152                          << option_def->getPosition() << 
")");
 
  162        opts_parser->parse(options, option_data);
 
  170                      << user_context->getPosition() << 
")");
 
  175    auto required_elem = class_def_cfg->get(
"only-if-required");
 
  176    auto additional_elem = class_def_cfg->get(
"only-in-additional-list");
 
  178        if (!additional_elem) {
 
  180            additional_elem = required_elem;
 
  183                      "cannot specify both 'only-if-required' and " 
  184                      "'only-in-additional-list'. Use only the latter.");
 
  188    bool additional = 
false;
 
  189    if (additional_elem) {
 
  191            additional = additional_elem->boolValue();
 
  194                      "'only-in-additional-list' must be boolean" 
  195                      << additional_elem->getPosition());
 
  201    if (class_def_cfg->contains(
"next-server")) {
 
  202        std::string next_server_txt = 
getString(class_def_cfg, 
"next-server");
 
  204            next_server = 
IOAddress(next_server_txt);
 
  207                      "Invalid next-server value specified: '" 
  208                      << next_server_txt << 
"' (" 
  209                      << 
getPosition(
"next-server", class_def_cfg) << 
")");
 
  212        if (next_server.
getFamily() != AF_INET) {
 
  214                      << next_server_txt << 
"', must be IPv4 address (" 
  215                      << 
getPosition(
"next-server", class_def_cfg) << 
")");
 
  220                      << next_server_txt << 
"', must not be a broadcast (" 
  221                      << 
getPosition(
"next-server", class_def_cfg) << 
")");
 
  227    if (class_def_cfg->contains(
"server-hostname")) {
 
  228        sname = 
getString(class_def_cfg, 
"server-hostname");
 
  233                      << sname.length() << 
" (" 
  234                      << 
getPosition(
"server-hostname", class_def_cfg) << 
")");
 
  239    std::string filename;
 
  240    if (class_def_cfg->contains(
"boot-file-name")) {
 
  241        filename = 
getString(class_def_cfg, 
"boot-file-name");
 
  246                      << filename.length() << 
" (" 
  247                      << 
getPosition(
"boot-file-name", class_def_cfg) << 
")");
 
  252    if (class_def_cfg->contains(
"offer-lifetime")) {
 
  253        auto value = 
getInteger(class_def_cfg, 
"offer-lifetime");
 
  256                      << value << 
"' must be a positive number (" 
  257                      << 
getPosition(
"offer-lifetime", class_def_cfg) << 
")");
 
  267    if (family != AF_INET) {
 
  277                          << 
"' only-in-additional-list flag must be false");
 
  281                          << 
"' test expression must be empty");
 
  287    if (name == 
"DROP") {
 
  290                      << 
"' only-in-additional-list flag must be false");
 
  305        class_dictionary->addClass(name, match_expr, 
test, additional,
 
  306                                   depend_on_known, options, defs,
 
  307                                   user_context, next_server, sname, filename,
 
  308                                   valid_lft, preferred_lft, is_template, offer_lft);
 
  309    } 
catch (
const std::exception& ex) {
 
  310        std::ostringstream s;
 
  311        s << 
"Can't add class: " << ex.what();
 
  313        if (append_error_position) {
 
  314            s << 
" (" << class_def_cfg->getPosition() << 
")";
 
 
  322                                               const uint16_t family) {
 
  324    if (!class_def_cfg || (class_def_cfg->getType() != 
Element::map)) {
 
  329    static std::set<std::string> supported_params = { 
"name",
 
  334                                                      "only-in-additional-list",
 
  336                                                      "min-valid-lifetime",
 
  337                                                      "max-valid-lifetime",
 
  341    static std::set<std::string> supported_params_v4 = { 
"option-def",
 
  347    static std::set<std::string> supported_params_v6 = { 
"preferred-lifetime",
 
  348                                                         "min-preferred-lifetime",
 
  349                                                         "max-preferred-lifetime" };
 
  352    for (
auto const& name_value_pair : class_def_cfg->mapValue()) {
 
  353        if ((supported_params.count(name_value_pair.first) > 0) ||
 
  354            ((family == AF_INET) && (supported_params_v4.count(name_value_pair.first) > 0)) ||
 
  355            ((family != AF_INET) && (supported_params_v6.count(name_value_pair.first) > 0))) {
 
  359                      << name_value_pair.first << 
"'");
 
 
  364boost::shared_ptr<OptionDataListParser>
 
  367    auto parser = boost::make_shared<OptionDataListParser>(address_family, cfg_option_def);
 
 
  375                                uint16_t family, 
bool check_dependencies) {
 
  377    for (
auto const& client_class_def : client_class_def_list->listValue()) {
 
  379        parser.
parse(dictionary, client_class_def, family, 
true, check_dependencies);
 
 
The IOAddress class represents an IP addresses (version agnostic)
bool isV4Bcast() const
Convenience function to check if it is an IPv4 broadcast address.
short getFamily() const
Returns the address family.
An exception that is thrown if an error occurs within the IO module.
static size_t setListDefaults(isc::data::ConstElementPtr list, const SimpleDefaults &default_values)
Sets the default values for all entries in a list.
static const data::Element::Position & getPosition(const std::string &name, const data::ConstElementPtr parent)
Utility method that returns position of an element.
static std::string getString(isc::data::ConstElementPtr scope, const std::string &name)
Returns a string parameter from a scope.
const isc::util::Triplet< uint32_t > parseIntTriplet(const data::ConstElementPtr &scope, const std::string &name)
Parses an integer triplet.
static int64_t getInteger(isc::data::ConstElementPtr scope, const std::string &name)
Returns an integer parameter from a scope.
Represents option definitions used by the DHCP server.
Represents option data configuration for the DHCP server.
ClientClassDictionaryPtr parse(isc::data::ConstElementPtr class_def_list, uint16_t family, bool check_dependencies=true)
Parse configuration entries.
Parser for a single client class definition.
virtual boost::shared_ptr< OptionDataListParser > createOptionDataListParser(const uint16_t address_family, CfgOptionDefPtr cfg_option_def) const
Returns an instance of the OptionDataListParser to be used in parsing the option-data structure.
void parse(ClientClassDictionaryPtr &class_dictionary, isc::data::ConstElementPtr client_class_def, uint16_t family, bool append_error_position=true, bool check_dependencies=true)
Parses an entry that describes single client class definition.
void checkParametersSupported(const isc::data::ConstElementPtr &class_def_cfg, const uint16_t family)
Iterates over class parameters and checks if they are supported.
Maintains a list of ClientClassDef's.
To be removed. Please use ConfigError instead.
Parser for a logical expression.
void parse(ExpressionPtr &expression, isc::data::ConstElementPtr expression_cfg, uint16_t family, isc::eval::EvalContext::CheckDefined check_defined=isc::eval::EvalContext::acceptAll, isc::eval::EvalContext::ParserType parser_type=isc::eval::EvalContext::PARSER_BOOL)
Parses an expression configuration element into an Expression.
static bool shouldDeferOptionUnpack(const std::string &space, const uint16_t code)
Checks if an option unpacking has to be deferred.
Parser for a single option definition.
OptionDefinitionPtr parse(isc::data::ConstElementPtr option_def)
Parses an entry that describes single option definition.
static const size_t MAX_SNAME_LEN
length of the SNAME field in DHCPv4 message
static const size_t MAX_FILE_LEN
length of the FILE field in DHCPv4 message
static const isc::data::SimpleDefaults OPTION4_DEF_DEFAULTS
This table defines default values for option definitions in DHCPv4.
static const isc::data::SimpleDefaults OPTION6_DEF_DEFAULTS
This table defines default values for option definitions in DHCPv6.
Evaluation context, an interface to the expression evaluation.
std::function< bool(const ClientClass &)> CheckDefined
Type of the check defined function.
bool parseString(const std::string &str, ParserType type=PARSER_BOOL)
Run the parser on the string specified.
ParserType
Specifies what type of expression the parser is expected to see.
@ PARSER_BOOL
expression is expected to evaluate to bool
@ PARSER_STRING
expression is expected to evaluate to string
static bool acceptAll(const ClientClass &client_class)
Accept all client class names.
isc::dhcp::Expression expression_
Parsed expression (output tokens are stored here)
A template representing an optional value.
void unspecified(bool unspecified)
Modifies the flag that indicates whether the value is specified or unspecified.
This template specifies a parameter value.
Defines classes for storing client class definitions.
Parsers for client class definitions.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
boost::shared_ptr< const Element > ConstElementPtr
isc::log::Logger dhcpsrv_logger("dhcpsrv")
DHCP server library Logger.
std::string ClientClass
Defines a single class name.
boost::shared_ptr< CfgOption > CfgOptionPtr
Non-const pointer.
boost::shared_ptr< CfgOptionDef > CfgOptionDefPtr
Non-const pointer.
const isc::log::MessageID DHCPSRV_CLASS_WITH_ADDITIONAL_AND_LIFETIMES
boost::shared_ptr< OptionDefinition > OptionDefinitionPtr
Pointer to option definition object.
boost::shared_ptr< Expression > ExpressionPtr
boost::shared_ptr< ClientClassDictionary > ClientClassDictionaryPtr
Defines a pointer to a ClientClassDictionary.
bool isClientClassDefined(ClientClassDictionaryPtr &class_dictionary, bool &depend_on_known, const ClientClass &client_class)
Check if a client class name is already defined, i.e.
const isc::log::MessageID DHCPSRV_ONLY_IF_REQUIRED_DEPRECATED
std::vector< TokenPtr > Expression
This is a structure that holds an expression converted to RPN.
std::list< std::string > builtinNames
List of classes for which test expressions cannot be defined.
Defines the logger used by the top-level component of kea-lfc.