/usr/include/boost/algorithm/string/detail/classification.hpp

Bug Summary

File:	usr/include/boost/algorithm/string/detail/classification.hpp
Warning:	line 141, column 17 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name option_definition.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/fedora/workspace/kea-dev/clang-static-analyzer/src/lib/dhcp -resource-dir /usr/lib64/clang/16 -D HAVE_CONFIG_H -I . -I ../../.. -I ../../../src/lib -I ../../../src/lib -D OS_LINUX -I ../../.. -I ../../.. -D PIC -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/13/../../../../include/c++/13/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/13/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wwrite-strings -Wno-sign-compare -Wno-missing-field-initializers -std=c++20 -fdeprecated-macro -fdebug-compilation-dir=/home/fedora/workspace/kea-dev/clang-static-analyzer/src/lib/dhcp -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fno-implicit-modules -fcxx-exceptions -fexceptions -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/fedora/workspace/kea-dev/clang-static-analyzer/report/2024-05-17-164749-18469-1 -x c++ option_definition.cc

option_definition.cc

→

1// Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.

7#include <config.h>

9#include <dhcp/dhcp4.h>
10#include <dhcp/dhcp6.h>
11#include <dhcp/option4_addrlst.h>
12#include <dhcp/option4_client_fqdn.h>
13#include <dhcp/option4_dnr.h>
14#include <dhcp/option6_addrlst.h>
15#include <dhcp/option6_client_fqdn.h>
16#include <dhcp/option6_dnr.h>
17#include <dhcp/option6_ia.h>
18#include <dhcp/option6_iaaddr.h>
19#include <dhcp/option6_iaprefix.h>
20#include <dhcp/option6_pdexclude.h>
21#include <dhcp/option6_status_code.h>
22#include <dhcp/option_custom.h>
23#include <dhcp/option_definition.h>
24#include <dhcp/option_int.h>
25#include <dhcp/option_int_array.h>
26#include <dhcp/option_opaque_data_tuples.h>
27#include <dhcp/option_classless_static_route.h>
28#include <dhcp/option_string.h>
29#include <dhcp/option_vendor.h>
30#include <dhcp/option_vendor_class.h>
31#include <util/encode/encode.h>
32#include <dns/labelsequence.h>
33#include <dns/name.h>
34#include <util/str.h>
35#include <boost/algorithm/string/classification.hpp>
36#include <boost/algorithm/string/predicate.hpp>
37#include <boost/algorithm/string/replace.hpp>
38#include <boost/dynamic_bitset.hpp>
39#include <boost/make_shared.hpp>
40#include <sstream>

42using namespace std;
43using namespace isc::util;

45namespace isc {
46namespace dhcp {

48OptionDefinition::OptionDefinition(const std::string& name,
                                 const uint16_t code,
                                 const std::string& space,
                                 const std::string& type,
                                 const bool array_type /* = false */)
  : name_(name),
    code_(code),
    type_(OPT_UNKNOWN_TYPE),
    array_type_(array_type),
    encapsulated_space_(""),
    record_fields_(),
    user_context_(),
    option_space_name_(space) {
  // Data type is held as enum value by this class.
  // Use the provided option type string to get the
  // corresponding enum value.
  type_ = OptionDataTypeUtil::getDataType(type);
65}

67OptionDefinition::OptionDefinition(const std::string& name,
                                 const uint16_t code,
                                 const std::string& space,
                                 const OptionDataType type,
                                 const bool array_type /* = false */)
  : name_(name),
    code_(code),
    type_(type),
    array_type_(array_type),
    encapsulated_space_(""),
    option_space_name_(space){
78}

80OptionDefinition::OptionDefinition(const std::string& name,
                                 const uint16_t code,
                                 const std::string& space,
                                 const std::string& type,
                                 const char* encapsulated_space)
  : name_(name),
    code_(code),
    // Data type is held as enum value by this class.
    // Use the provided option type string to get the
    // corresponding enum value.
    type_(OptionDataTypeUtil::getDataType(type)),
    array_type_(false),
    encapsulated_space_(encapsulated_space),
    record_fields_(),
    user_context_(),
    option_space_name_(space) {
96}

98OptionDefinition::OptionDefinition(const std::string& name,
                                 const uint16_t code,
                                 const std::string& space,
                                 const OptionDataType type,
                                 const char* encapsulated_space)
  : name_(name),
    code_(code),
    type_(type),
    array_type_(false),
    encapsulated_space_(encapsulated_space),
    record_fields_(),
    user_context_(),
    option_space_name_(space) {
111}

113OptionDefinitionPtr
114OptionDefinition::create(const std::string& name,
                       const uint16_t code,
                       const std::string& space,
                       const std::string& type,
                       const bool array_type) {
  return (boost::make_shared<OptionDefinition>(name, code, space, type, array_type));
120}

122OptionDefinitionPtr
123OptionDefinition::create(const std::string& name,
                       const uint16_t code,
                       const std::string& space,
                       const OptionDataType type,
                       const bool array_type) {
  return (boost::make_shared<OptionDefinition>(name, code, space, type, array_type));
129}

131OptionDefinitionPtr
132OptionDefinition::create(const std::string& name,
                       const uint16_t code,
                       const std::string& space,
                       const std::string& type,
                       const char* encapsulated_space) {
  return (boost::make_shared<OptionDefinition>(name, code, space, type, encapsulated_space));
138}

140OptionDefinitionPtr
141OptionDefinition::create(const std::string& name,
                       const uint16_t code,
                       const std::string& space,
                       const OptionDataType type,
                       const char* encapsulated_space) {
  return (boost::make_shared<OptionDefinition>(name, code, space, type, encapsulated_space));
147}

149bool
150OptionDefinition::equals(const OptionDefinition& other) const {
  return (name_ == other.name_ &&
          code_ == other.code_ &&
          type_ == other.type_ &&
          array_type_ == other.array_type_ &&
          encapsulated_space_ == other.encapsulated_space_ &&
          record_fields_ == other.record_fields_ &&
          option_space_name_ == other.option_space_name_);
158}

160void
161OptionDefinition::addRecordField(const std::string& data_type_name) {
  OptionDataType data_type = OptionDataTypeUtil::getDataType(data_type_name);
  addRecordField(data_type);
164}

166void
167OptionDefinition::addRecordField(const OptionDataType data_type) {
  if (type_ != OPT_RECORD_TYPE) {
      isc_throw(isc::InvalidOperation,do { std::ostringstream oss__; oss__ << "'record' option type must be used instead of '"
 << OptionDataTypeUtil::getDataTypeName(type_) <<
 "' to add data fields to the record"; throw isc::InvalidOperation
("option_definition.cc", 172, oss__.str().c_str()); } while (
1)
                "'record' option type must be used instead of '"do { std::ostringstream oss__; oss__ << "'record' option type must be used instead of '"
 << OptionDataTypeUtil::getDataTypeName(type_) <<
 "' to add data fields to the record"; throw isc::InvalidOperation
("option_definition.cc", 172, oss__.str().c_str()); } while (
1)
                    << OptionDataTypeUtil::getDataTypeName(type_)do { std::ostringstream oss__; oss__ << "'record' option type must be used instead of '"
 << OptionDataTypeUtil::getDataTypeName(type_) <<
 "' to add data fields to the record"; throw isc::InvalidOperation
("option_definition.cc", 172, oss__.str().c_str()); } while (
1)
                    << "' to add data fields to the record")do { std::ostringstream oss__; oss__ << "'record' option type must be used instead of '"
 << OptionDataTypeUtil::getDataTypeName(type_) <<
 "' to add data fields to the record"; throw isc::InvalidOperation
("option_definition.cc", 172, oss__.str().c_str()); } while (
1);
  }
  if (data_type >= OPT_RECORD_TYPE ||
      data_type == OPT_ANY_ADDRESS_TYPE ||
      data_type == OPT_EMPTY_TYPE) {
      isc_throw(isc::BadValue,do { std::ostringstream oss__; oss__ << "attempted to add invalid data type '"
 << OptionDataTypeUtil::getDataTypeName(data_type) <<
 "' to the record."; throw isc::BadValue("option_definition.cc"
, 180, oss__.str().c_str()); } while (1)
                "attempted to add invalid data type '"do { std::ostringstream oss__; oss__ << "attempted to add invalid data type '"
 << OptionDataTypeUtil::getDataTypeName(data_type) <<
 "' to the record."; throw isc::BadValue("option_definition.cc"
, 180, oss__.str().c_str()); } while (1)
                    << OptionDataTypeUtil::getDataTypeName(data_type)do { std::ostringstream oss__; oss__ << "attempted to add invalid data type '"
 << OptionDataTypeUtil::getDataTypeName(data_type) <<
 "' to the record."; throw isc::BadValue("option_definition.cc"
, 180, oss__.str().c_str()); } while (1)
                    << "' to the record.")do { std::ostringstream oss__; oss__ << "attempted to add invalid data type '"
 << OptionDataTypeUtil::getDataTypeName(data_type) <<
 "' to the record."; throw isc::BadValue("option_definition.cc"
, 180, oss__.str().c_str()); } while (1);
  }
  record_fields_.push_back(data_type);
183}

185OptionPtr
186OptionDefinition::optionFactory(Option::Universe u,
                              uint16_t type,
                              OptionBufferConstIter begin,
                              OptionBufferConstIter end,
                              bool convenient_notation) const {

  try {
      // Some of the options are represented by the specialized classes derived
      // from Option class (e.g. IA_NA, IAADDR). Although, they can be also
      // represented by the generic classes, we want the object of the specialized
      // type to be returned. Therefore, we first check that if we are dealing
      // with such an option. If the instance is returned we just exit at this
      // point. If not, we will search for a generic option type to return.
      OptionPtr option = factorySpecialFormatOption(u, begin, end, convenient_notation);
      if (option) {
          return (option);
      }

      switch (type_) {
      case OPT_EMPTY_TYPE:
          if (getEncapsulatedSpace().empty()) {
              return (factoryEmpty(u, type));
          } else {
              return (OptionPtr(new OptionCustom(*this, u, begin, end)));
          }

      case OPT_BINARY_TYPE:
      // If this is Internal type, and it wasn't handled by factorySpecialFormatOption() before,
      // let's treat it like normal Binary type.
      case OPT_INTERNAL_TYPE:
          return (factoryGeneric(u, type, begin, end));

      case OPT_UINT8_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<uint8_t>(u, type, begin, end) :
                  factoryInteger<uint8_t>(u, type, getEncapsulatedSpace(),
                                          begin, end));

      case OPT_INT8_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<int8_t>(u, type, begin, end) :
                  factoryInteger<int8_t>(u, type, getEncapsulatedSpace(),
                                         begin, end));

      case OPT_UINT16_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<uint16_t>(u, type, begin, end) :
                  factoryInteger<uint16_t>(u, type, getEncapsulatedSpace(),
                                           begin, end));

      case OPT_INT16_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<uint16_t>(u, type, begin, end) :
                  factoryInteger<int16_t>(u, type, getEncapsulatedSpace(),
                                          begin, end));

      case OPT_UINT32_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<uint32_t>(u, type, begin, end) :
                  factoryInteger<uint32_t>(u, type, getEncapsulatedSpace(),
                                           begin, end));

      case OPT_INT32_TYPE:
          return (array_type_ ?
                  factoryIntegerArray<uint32_t>(u, type, begin, end) :
                  factoryInteger<int32_t>(u, type, getEncapsulatedSpace(),
                                          begin, end));

      case OPT_IPV4_ADDRESS_TYPE:
          // If definition specifies that an option is an array
          // of IPv4 addresses we return an instance of specialized
          // class (OptionAddrLst4). For non-array types there is no
          // specialized class yet implemented so we drop through
          // to return an instance of OptionCustom.
          if (array_type_) {
              return (factoryAddrList4(type, begin, end));
          }
          break;

      case OPT_IPV6_ADDRESS_TYPE:
          // Handle array type only here (see comments for
          // OPT_IPV4_ADDRESS_TYPE case).
          if (array_type_) {
              return (factoryAddrList6(type, begin, end));
          }
          break;

      case OPT_STRING_TYPE:
          return (OptionPtr(new OptionString(u, type, begin, end)));

      case OPT_TUPLE_TYPE:
          // Handle array type only here (see comments for
          // OPT_IPV4_ADDRESS_TYPE case).
          if (array_type_) {
              return (factoryOpaqueDataTuples(u, type, begin, end));
          }
          break;

      default:
          // Do nothing. We will return generic option a few lines down.
          ;
      }
      return (OptionPtr(new OptionCustom(*this, u, begin, end)));
  } catch (const SkipThisOptionError&) {
      // We need to throw this one as is.
      throw;
  } catch (const SkipRemainingOptionsError&) {
      // We need to throw this one as is.
      throw;
  } catch (const Exception& ex) {
      isc_throw(InvalidOptionValue, ex.what())do { std::ostringstream oss__; oss__ << ex.what(); throw
 InvalidOptionValue("option_definition.cc", 296, oss__.str().
c_str()); } while (1);
  }
298}

300OptionPtr
301OptionDefinition::optionFactory(Option::Universe u, uint16_t type,
                              const OptionBuffer& buf) const {
  return (optionFactory(u, type, buf.begin(), buf.end()));
304}

306OptionPtr
307OptionDefinition::optionFactory(Option::Universe u, uint16_t type,
                              const std::vector<std::string>& values) const {
  OptionBuffer buf;
  if (!array_type_ && type_ != OPT_RECORD_TYPE) {
      if (values.empty()) {
          if (type_ != OPT_EMPTY_TYPE) {
              isc_throw(InvalidOptionValue, "no option value specified")do { std::ostringstream oss__; oss__ << "no option value specified"
; throw InvalidOptionValue("option_definition.cc", 313, oss__
.str().c_str()); } while (1);
          }
      } else if (type_ == OPT_INTERNAL_TYPE) {
          // If an Option of type Internal is configured using csv-format=true, it means it is
          // convenient notation option config that needs special parsing. Let's treat it like
          // String type. optionFactory() will be called with convenient_notation flag set to
          // true, so that the factory will have a chance to handle it in a special way.

          // At this stage any escape backslash chars were lost during last call of
          // isc::util::str::tokens() inside of
          // OptionDataParser::createOption(ConstElementPtr option_data), so we must
          // restore them. Some INTERNAL options may use escaped delimiters, e.g. DNR options.
          // Values are concatenated back to comma separated format and will be written to
          // the OptionBuffer as one String type option.
          std::ostringstream stream;
          bool first = true;
          for (auto val : values) {
              boost::algorithm::replace_all(val, ",", "\\,");
              if (first) {
                  first = false;
              } else {
                  stream << ",";
              }

              stream << val;
          }

          writeToBuffer(u, stream.str(), OPT_STRING_TYPE, buf);
      } else {
          writeToBuffer(u, util::str::trim(values[0]), type_, buf);
      }
  } else if (array_type_ && type_ != OPT_RECORD_TYPE) {
      for (size_t i = 0; i < values.size(); ++i) {
          writeToBuffer(u, util::str::trim(values[i]), type_, buf);
      }
  } else if (type_ == OPT_RECORD_TYPE) {
      const RecordFieldsCollection& records = getRecordFields();
      if (records.size() > values.size()) {
          isc_throw(InvalidOptionValue, "number of data fields for the option"do { std::ostringstream oss__; oss__ << "number of data fields for the option"
 << " type '" << getCode() << "' is greater than number"
 << " of values provided."; throw InvalidOptionValue("option_definition.cc"
, 353, oss__.str().c_str()); } while (1)
                    << " type '" <<  getCode() << "' is greater than number"do { std::ostringstream oss__; oss__ << "number of data fields for the option"
 << " type '" << getCode() << "' is greater than number"
 << " of values provided."; throw InvalidOptionValue("option_definition.cc"
, 353, oss__.str().c_str()); } while (1)
                    << " of values provided.")do { std::ostringstream oss__; oss__ << "number of data fields for the option"
 << " type '" << getCode() << "' is greater than number"
 << " of values provided."; throw InvalidOptionValue("option_definition.cc"
, 353, oss__.str().c_str()); } while (1);
      }
      for (size_t i = 0; i < records.size(); ++i) {
          writeToBuffer(u, util::str::trim(values[i]), records[i], buf);
      }
      if (array_type_ && (values.size() > records.size())) {
          for (size_t i = records.size(); i < values.size(); ++i) {
              writeToBuffer(u, util::str::trim(values[i]),
                            records.back(), buf);
          }
      }
  }
  return (optionFactory(u, type, buf.begin(), buf.end(), (type_ == OPT_INTERNAL_TYPE)));
366}

368void
369OptionDefinition::validate() const {

  using namespace boost::algorithm;

  std::ostringstream err_str;

  // Allowed characters in the option name are: lower or
  // upper case letters, digits, underscores and hyphens.
  // Empty option spaces are not allowed.
  if (!all(name_, boost::is_from_range('a', 'z') ||
1
Calling 'operator||<boost::algorithm::detail::pred_orF<boost::algorithm::detail::pred_orF<boost::algorithm::detail::is_from_rangeF<char>, boost::algorithm::detail::is_from_rangeF<char>>, boost::algorithm::detail::is_classifiedF>, boost::algorithm::detail::is_any_ofF<char>>'→
           boost::is_from_range('A', 'Z') ||
           boost::is_digit() ||
           boost::is_any_of(std::string("-_"))) ||
      name_.empty() ||
      // Hyphens and underscores are not allowed at the beginning
      // and at the end of the option name.
      all(find_head(name_, 1), boost::is_any_of(std::string("-_"))) ||
      all(find_tail(name_, 1), boost::is_any_of(std::string("-_")))) {
      err_str << "invalid option name '" << name_ << "'";

  } else if (!OptionSpace::validateName(option_space_name_)) {
      err_str << "invalid option space name: '"
              << option_space_name_ << "'";

  } else if (!encapsulated_space_.empty() &&
             !OptionSpace::validateName(encapsulated_space_)) {
      err_str << "invalid encapsulated option space name: '"
              << encapsulated_space_ << "'";

  } else if (type_ >= OPT_UNKNOWN_TYPE) {
      // Option definition must be of a known type.
      err_str << "option type " << type_ << " not supported.";

  } else if (type_ == OPT_RECORD_TYPE) {
      // At least two data fields should be added to the record. Otherwise
      // non-record option definition could be used.
      if (getRecordFields().size() < 2) {
          err_str << "invalid number of data fields: "
                  << getRecordFields().size()
                  << " specified for the option of type 'record'. Expected at"
                  << " least 2 fields.";

      } else {
          // If the number of fields is valid we have to check if their order
          // is valid too. We check that string or binary data fields are not
          // laid before other fields. But we allow that they are laid at the
          // end of an option.
          const RecordFieldsCollection& fields = getRecordFields();
          for (RecordFieldsConstIter it = fields.begin();
               it != fields.end(); ++it) {
              if (*it == OPT_STRING_TYPE &&
                  it < fields.end() - 1) {
                  err_str << "string data field can't be laid before data"
                          << " fields of other types.";
                  break;
              }
              if (*it == OPT_BINARY_TYPE &&
                  it < fields.end() - 1) {
                  err_str << "binary data field can't be laid before data"
                          << " fields of other types.";
                  break;
              }
              // Empty type is not allowed within a record.
              if (*it == OPT_EMPTY_TYPE) {
                  err_str << "empty data type can't be stored as a field in"
                          << " an option record.";
                  break;
              }
              // Internal type is not allowed within a record.
              if (*it == OPT_INTERNAL_TYPE) {
                  err_str << "internal data type can't be stored as a field in"
                          << " an option record.";
                  break;
              }
          }
          // If the array flag is set the last field is an array.
          if (err_str.str().empty() && array_type_) {
              const OptionDataType& last_type = fields.back();
              if (last_type == OPT_STRING_TYPE) {
                  err_str
                      << "array of strings is not a valid option definition.";
              } else if (last_type == OPT_BINARY_TYPE) {
                  err_str << "array of binary values is not a valid option "
                             "definition.";
              }
              // Empty type was already checked.
          }
      }

  } else if (array_type_) {
      if (type_ == OPT_STRING_TYPE) {
          // Array of strings is not allowed because there is no way
          // to determine the size of a particular string and thus there
          // it no way to tell when other data fields begin.
          err_str << "array of strings is not a valid option definition.";
      } else if (type_ == OPT_BINARY_TYPE) {
          err_str << "array of binary values is not"
                  << " a valid option definition.";

      } else if (type_ == OPT_EMPTY_TYPE) {
          err_str << "array of empty value is not"
                  << " a valid option definition.";

      } else if (type_ == OPT_INTERNAL_TYPE) {
          err_str << "array of internal type value is not"
                  << " a valid option definition.";

      }
  }

  // Non-empty error string means that we have hit the error. We throw
  // exception and include error string.
  if (!err_str.str().empty()) {
      isc_throw(MalformedOptionDefinition, err_str.str())do { std::ostringstream oss__; oss__ << err_str.str(); throw
 MalformedOptionDefinition("option_definition.cc", 482, oss__
.str().c_str()); } while (1);
  }
484}

486bool
487OptionDefinition::haveCompressedFqdnListFormat() const {
  return (haveType(OPT_FQDN_TYPE) && getArrayType());
489}

491bool
492OptionDefinition::convertToBool(const std::string& value_str) const {
  // Case-insensitive check that the input is one of: "true" or "false".
  if (boost::iequals(value_str, "true")) {
      return (true);

  } else if (boost::iequals(value_str, "false")) {
      return (false);

  }

  // The input string is neither "true" nor "false", so let's check
  // if it is not an integer wrapped in a string.
  int result;
  try {
      result = boost::lexical_cast<int>(value_str);

  } catch (const boost::bad_lexical_cast&) {
      isc_throw(BadDataTypeCast, "unable to covert the value '"do { std::ostringstream oss__; oss__ << "unable to covert the value '"
 << value_str << "' to boolean data type"; throw BadDataTypeCast
("option_definition.cc", 510, oss__.str().c_str()); } while (
1)
                << value_str << "' to boolean data type")do { std::ostringstream oss__; oss__ << "unable to covert the value '"
 << value_str << "' to boolean data type"; throw BadDataTypeCast
("option_definition.cc", 510, oss__.str().c_str()); } while (
1);
  }
  // The boolean value is encoded in DHCP option as 0 or 1. Therefore,
  // we only allow a user to specify those values for options which
  // have boolean fields.
  if (result != 1 && result != 0) {
      isc_throw(BadDataTypeCast, "unable to convert '" << value_strdo { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to boolean data type"; throw BadDataTypeCast
("option_definition.cc", 517, oss__.str().c_str()); } while (
1)
                << "' to boolean data type")do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to boolean data type"; throw BadDataTypeCast
("option_definition.cc", 517, oss__.str().c_str()); } while (
1);
  }
  return (static_cast<bool>(result));
520}

522template<typename T>
523T
524OptionDefinition::lexicalCastWithRangeCheck(const std::string& value_str)
  const {
  // The lexical cast should be attempted when converting to an integer
  // value only.
  if (!OptionDataTypeTraits<T>::integer_type) {
      isc_throw(BadDataTypeCast,do { std::ostringstream oss__; oss__ << "must not convert '"
 << value_str << "' to non-integer data type"; throw
 BadDataTypeCast("option_definition.cc", 531, oss__.str().c_str
()); } while (1)
                "must not convert '" << value_strdo { std::ostringstream oss__; oss__ << "must not convert '"
 << value_str << "' to non-integer data type"; throw
 BadDataTypeCast("option_definition.cc", 531, oss__.str().c_str
()); } while (1)
                << "' to non-integer data type")do { std::ostringstream oss__; oss__ << "must not convert '"
 << value_str << "' to non-integer data type"; throw
 BadDataTypeCast("option_definition.cc", 531, oss__.str().c_str
()); } while (1);
  }

  // We use the 64-bit value here because it has wider range than
  // any other type we use here and it allows to detect out of
  // bounds conditions e.g. negative value specified for uintX_t
  // data type. Obviously if the value exceeds the limits of int64
  // this function will not handle that properly.
  int64_t result = 0;
  try {
      result = boost::lexical_cast<int64_t>(value_str);

  } catch (const boost::bad_lexical_cast&) {
      // boost::lexical_cast does not handle hexadecimal
      // but stringstream does so do it the hard way.
      std::stringstream ss;
      ss << std::hex << value_str;
      ss >> result;
      if (ss.fail() || !ss.eof()) {
          isc_throw(BadDataTypeCast, "unable to convert the value '"do { std::ostringstream oss__; oss__ << "unable to convert the value '"
 << value_str << "' to integer data type"; throw BadDataTypeCast
("option_definition.cc", 551, oss__.str().c_str()); } while (
1)
                    << value_str << "' to integer data type")do { std::ostringstream oss__; oss__ << "unable to convert the value '"
 << value_str << "' to integer data type"; throw BadDataTypeCast
("option_definition.cc", 551, oss__.str().c_str()); } while (
1);
      }
  }
  // Perform range checks.
  if (OptionDataTypeTraits<T>::integer_type) {
      if (result > numeric_limits<T>::max() ||
          result < numeric_limits<T>::min()) {
          isc_throw(BadDataTypeCast, "unable to convert '"do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to numeric type. This value is "
 "expected to be in the range of " << +numeric_limits<
T>::min() << ".." << +numeric_limits<T>::
max(); throw BadDataTypeCast("option_definition.cc", 562, oss__
.str().c_str()); } while (1)
                    << value_str << "' to numeric type. This value is "do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to numeric type. This value is "
 "expected to be in the range of " << +numeric_limits<
T>::min() << ".." << +numeric_limits<T>::
max(); throw BadDataTypeCast("option_definition.cc", 562, oss__
.str().c_str()); } while (1)
                       "expected to be in the range of "do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to numeric type. This value is "
 "expected to be in the range of " << +numeric_limits<
T>::min() << ".." << +numeric_limits<T>::
max(); throw BadDataTypeCast("option_definition.cc", 562, oss__
.str().c_str()); } while (1)
                    << +numeric_limits<T>::min() << ".."do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to numeric type. This value is "
 "expected to be in the range of " << +numeric_limits<
T>::min() << ".." << +numeric_limits<T>::
max(); throw BadDataTypeCast("option_definition.cc", 562, oss__
.str().c_str()); } while (1)
                    << +numeric_limits<T>::max())do { std::ostringstream oss__; oss__ << "unable to convert '"
 << value_str << "' to numeric type. This value is "
 "expected to be in the range of " << +numeric_limits<
T>::min() << ".." << +numeric_limits<T>::
max(); throw BadDataTypeCast("option_definition.cc", 562, oss__
.str().c_str()); } while (1);
      }
  }
  return (static_cast<T>(result));
566}

568void
569OptionDefinition::writeToBuffer(Option::Universe u,
                              const std::string& value,
                              const OptionDataType type,
                              OptionBuffer& buf) const {
  // We are going to write value given by value argument to the buffer.
  // The actual type of the value is given by second argument. Check
  // this argument to determine how to write this value to the buffer.
  switch (type) {
  case OPT_BINARY_TYPE:
      OptionDataTypeUtil::writeBinary(value, buf);
      return;
  case OPT_BOOLEAN_TYPE:
      // We encode the true value as 1 and false as 0 on 8 bits.
      // That way we actually waste 7 bits but it seems to be the
      // simpler way to encode boolean.
      // @todo Consider if any other encode methods can be used.
      OptionDataTypeUtil::writeBool(convertToBool(value), buf);
      return;
  case OPT_INT8_TYPE:
      OptionDataTypeUtil::writeInt<uint8_t>
          (lexicalCastWithRangeCheck<int8_t>(value),
                                            buf);
      return;
  case OPT_INT16_TYPE:
      OptionDataTypeUtil::writeInt<uint16_t>
          (lexicalCastWithRangeCheck<int16_t>(value),
                                             buf);
      return;
  case OPT_INT32_TYPE:
      OptionDataTypeUtil::writeInt<uint32_t>
          (lexicalCastWithRangeCheck<int32_t>(value),
                                             buf);
      return;
  case OPT_UINT8_TYPE:
      OptionDataTypeUtil::writeInt<uint8_t>
          (lexicalCastWithRangeCheck<uint8_t>(value),
                                            buf);
      return;
  case OPT_UINT16_TYPE:
      OptionDataTypeUtil::writeInt<uint16_t>
          (lexicalCastWithRangeCheck<uint16_t>(value),
                                             buf);
      return;
  case OPT_UINT32_TYPE:
      OptionDataTypeUtil::writeInt<uint32_t>
          (lexicalCastWithRangeCheck<uint32_t>(value),
                                             buf);
      return;
  case OPT_IPV4_ADDRESS_TYPE:
  case OPT_IPV6_ADDRESS_TYPE:
      {
          asiolink::IOAddress address(value);
          if (!address.isV4() && !address.isV6()) {
              isc_throw(BadDataTypeCast, "provided address "do { std::ostringstream oss__; oss__ << "provided address "
 << address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 624, oss__.str
().c_str()); } while (1)
                        << addressdo { std::ostringstream oss__; oss__ << "provided address "
 << address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 624, oss__.str
().c_str()); } while (1)
                        << " is not a valid IPv4 or IPv6 address.")do { std::ostringstream oss__; oss__ << "provided address "
 << address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 624, oss__.str
().c_str()); } while (1);
          }
          OptionDataTypeUtil::writeAddress(address, buf);
          return;
      }
  case OPT_IPV6_PREFIX_TYPE:
      {
          std::string txt = value;

          // first let's remove any whitespaces
          boost::erase_all(txt, " "); // space
          boost::erase_all(txt, "\t"); // tabulation

          // Is this prefix/len notation?
          size_t pos = txt.find("/");

          if (pos == string::npos) {
              isc_throw(BadDataTypeCast, "provided address/prefix "do { std::ostringstream oss__; oss__ << "provided address/prefix "
 << value << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 643, oss__.str().c_str()); } while (
1)
                        << valuedo { std::ostringstream oss__; oss__ << "provided address/prefix "
 << value << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 643, oss__.str().c_str()); } while (
1)
                        << " is not valid.")do { std::ostringstream oss__; oss__ << "provided address/prefix "
 << value << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 643, oss__.str().c_str()); } while (
1);
          }

          std::string txt_address = txt.substr(0, pos);
          isc::asiolink::IOAddress address = isc::asiolink::IOAddress(txt_address);
          if (!address.isV6()) {
              isc_throw(BadDataTypeCast, "provided address "do { std::ostringstream oss__; oss__ << "provided address "
 << txt_address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 651, oss__.str
().c_str()); } while (1)
                        << txt_addressdo { std::ostringstream oss__; oss__ << "provided address "
 << txt_address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 651, oss__.str
().c_str()); } while (1)
                        << " is not a valid IPv4 or IPv6 address.")do { std::ostringstream oss__; oss__ << "provided address "
 << txt_address << " is not a valid IPv4 or IPv6 address."
; throw BadDataTypeCast("option_definition.cc", 651, oss__.str
().c_str()); } while (1);
          }

          std::string txt_prefix = txt.substr(pos + 1);
          uint8_t len = 0;
          try {
              // start with the first character after /
              len = lexicalCastWithRangeCheck<uint8_t>(txt_prefix);
          } catch (...)  {
              isc_throw(BadDataTypeCast, "provided prefix "do { std::ostringstream oss__; oss__ << "provided prefix "
 << txt_prefix << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 662, oss__.str().c_str()); } while (
1)
                        << txt_prefixdo { std::ostringstream oss__; oss__ << "provided prefix "
 << txt_prefix << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 662, oss__.str().c_str()); } while (
1)
                        << " is not valid.")do { std::ostringstream oss__; oss__ << "provided prefix "
 << txt_prefix << " is not valid."; throw BadDataTypeCast
("option_definition.cc", 662, oss__.str().c_str()); } while (
1);
          }

          // Write a prefix.
          OptionDataTypeUtil::writePrefix(PrefixLen(len), address, buf);

          return;
      }
  case OPT_PSID_TYPE:
      {
      std::string txt = value;

      // first let's remove any whitespaces
      boost::erase_all(txt, " "); // space
      boost::erase_all(txt, "\t"); // tabulation

      // Is this prefix/len notation?
      size_t pos = txt.find("/");

      if (pos == string::npos) {
          isc_throw(BadDataTypeCast, "provided PSID value "do { std::ostringstream oss__; oss__ << "provided PSID value "
 << value << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 683, oss__.str().c_str()); } while (
1)
                    << value << " is not valid")do { std::ostringstream oss__; oss__ << "provided PSID value "
 << value << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 683, oss__.str().c_str()); } while (
1);
      }

      const std::string txt_psid = txt.substr(0, pos);
      const std::string txt_psid_len = txt.substr(pos + 1);

      uint16_t psid = 0;
      uint8_t psid_len = 0;

      try {
          psid = lexicalCastWithRangeCheck<uint16_t>(txt_psid);
      } catch (...)  {
          isc_throw(BadDataTypeCast, "provided PSID "do { std::ostringstream oss__; oss__ << "provided PSID "
 << txt_psid << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 696, oss__.str().c_str()); } while (
1)
                    << txt_psid << " is not valid")do { std::ostringstream oss__; oss__ << "provided PSID "
 << txt_psid << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 696, oss__.str().c_str()); } while (
1);
      }

      try {
          psid_len = lexicalCastWithRangeCheck<uint8_t>(txt_psid_len);
      } catch (...)  {
          isc_throw(BadDataTypeCast, "provided PSID length "do { std::ostringstream oss__; oss__ << "provided PSID length "
 << txt_psid_len << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 703, oss__.str().c_str()); } while (
1)
                    << txt_psid_len << " is not valid")do { std::ostringstream oss__; oss__ << "provided PSID length "
 << txt_psid_len << " is not valid"; throw BadDataTypeCast
("option_definition.cc", 703, oss__.str().c_str()); } while (
1);
      }

      OptionDataTypeUtil::writePsid(PSIDLen(psid_len), PSID(psid), buf);
      return;
  }
  case OPT_STRING_TYPE:
      OptionDataTypeUtil::writeString(value, buf);
      return;
  case OPT_FQDN_TYPE:
      OptionDataTypeUtil::writeFqdn(value, buf);
      return;
  case OPT_TUPLE_TYPE:
  {
      // In case of V4_SZTP_REDIRECT option #143, bootstrap-server-list is formatted
      // as a list of tuples "uri-length;URI" where uri-length is coded on 2 octets,
      // which is not typical for V4 Universe.
      OpaqueDataTuple::LengthFieldType lft = getCode() == DHO_V4_SZTP_REDIRECT
                                                 ? OpaqueDataTuple::LENGTH_2_BYTES
                                                 : OptionDataTypeUtil::getTupleLenFieldType(u);
      OptionDataTypeUtil::writeTuple(value, lft, buf);
      return;
  }
  default:
      // We hit this point because invalid option data type has been specified
      // This may be the case because 'empty' or 'record' data type has been
      // specified. We don't throw exception here because it will be thrown
      // at the exit point from this function.
      ;
  }
  isc_throw(isc::BadValue, "attempt to write invalid option data field type"do { std::ostringstream oss__; oss__ << "attempt to write invalid option data field type"
 " into the option buffer: " << type; throw isc::BadValue
("option_definition.cc", 734, oss__.str().c_str()); } while (
1)
            " into the option buffer: " << type)do { std::ostringstream oss__; oss__ << "attempt to write invalid option data field type"
 " into the option buffer: " << type; throw isc::BadValue
("option_definition.cc", 734, oss__.str().c_str()); } while (
1);

736}

738OptionPtr
739OptionDefinition::factoryAddrList4(uint16_t type,
                                OptionBufferConstIter begin,
                                OptionBufferConstIter end) {
  boost::shared_ptr<Option4AddrLst> option(new Option4AddrLst(type, begin,
                                                              end));
  return (option);
745}

747OptionPtr
748OptionDefinition::factoryAddrList6(uint16_t type,
                                 OptionBufferConstIter begin,
                                 OptionBufferConstIter end) {
  boost::shared_ptr<Option6AddrLst> option(new Option6AddrLst(type, begin,
                                                              end));
  return (option);
754}


757OptionPtr
758OptionDefinition::factoryEmpty(Option::Universe u, uint16_t type) {
  OptionPtr option(new Option(u, type));
  return (option);
761}

763OptionPtr
764OptionDefinition::factoryGeneric(Option::Universe u, uint16_t type,
                               OptionBufferConstIter begin,
                               OptionBufferConstIter end) {
  OptionPtr option(new Option(u, type, begin, end));
  return (option);
769}

771OptionPtr
772OptionDefinition::factoryIA6(uint16_t type,
                           OptionBufferConstIter begin,
                           OptionBufferConstIter end) {
  if (std::distance(begin, end) < Option6IA::OPTION6_IA_LEN) {
      isc_throw(isc::OutOfRange, "input option buffer has invalid size,"do { std::ostringstream oss__; oss__ << "input option buffer has invalid size,"
 << " expected at least " << Option6IA::OPTION6_IA_LEN
 << " bytes"; throw isc::OutOfRange("option_definition.cc"
, 778, oss__.str().c_str()); } while (1)
                << " expected at least " << Option6IA::OPTION6_IA_LENdo { std::ostringstream oss__; oss__ << "input option buffer has invalid size,"
 << " expected at least " << Option6IA::OPTION6_IA_LEN
 << " bytes"; throw isc::OutOfRange("option_definition.cc"
, 778, oss__.str().c_str()); } while (1)
                << " bytes")do { std::ostringstream oss__; oss__ << "input option buffer has invalid size,"
 << " expected at least " << Option6IA::OPTION6_IA_LEN
 << " bytes"; throw isc::OutOfRange("option_definition.cc"
, 778, oss__.str().c_str()); } while (1);
  }
  boost::shared_ptr<Option6IA> option(new Option6IA(type, begin, end));
  return (option);
782}

784OptionPtr
785OptionDefinition::factoryIAAddr6(uint16_t type,
                               OptionBufferConstIter begin,
                               OptionBufferConstIter end) {
  if (std::distance(begin, end) < Option6IAAddr::OPTION6_IAADDR_LEN) {
      isc_throw(isc::OutOfRange,do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAAddr::OPTION6_IAADDR_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 791, oss__.str
().c_str()); } while (1)
                "input option buffer has invalid size, expected at least "do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAAddr::OPTION6_IAADDR_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 791, oss__.str
().c_str()); } while (1)
                << Option6IAAddr::OPTION6_IAADDR_LEN << " bytes")do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAAddr::OPTION6_IAADDR_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 791, oss__.str
().c_str()); } while (1);
  }
  boost::shared_ptr<Option6IAAddr> option(new Option6IAAddr(type, begin,
                                                            end));
  return (option);
796}

798OptionPtr
799OptionDefinition::factoryIAPrefix6(uint16_t type,
                               OptionBufferConstIter begin,
                               OptionBufferConstIter end) {
  if (std::distance(begin, end) < Option6IAPrefix::OPTION6_IAPREFIX_LEN) {
      isc_throw(isc::OutOfRange,do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAPrefix::OPTION6_IAPREFIX_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 805, oss__.str
().c_str()); } while (1)
                "input option buffer has invalid size, expected at least "do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAPrefix::OPTION6_IAPREFIX_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 805, oss__.str
().c_str()); } while (1)
                << Option6IAPrefix::OPTION6_IAPREFIX_LEN << " bytes")do { std::ostringstream oss__; oss__ << "input option buffer has invalid size, expected at least "
 << Option6IAPrefix::OPTION6_IAPREFIX_LEN << " bytes"
; throw isc::OutOfRange("option_definition.cc", 805, oss__.str
().c_str()); } while (1);
  }
  boost::shared_ptr<Option6IAPrefix> option(new Option6IAPrefix(type, begin,
                                                                end));
  return (option);
810}

812OptionPtr
813OptionDefinition::factoryOpaqueDataTuples(Option::Universe u,
                                        uint16_t type,
                                        OptionBufferConstIter begin,
                                        OptionBufferConstIter end) {
  boost::shared_ptr<OptionOpaqueDataTuples>
      option(new OptionOpaqueDataTuples(u, type, begin, end));

  return (option);
821}

823OptionPtr
824OptionDefinition::factoryOpaqueDataTuples(Option::Universe u,
                                        uint16_t type,
                                        OptionBufferConstIter begin,
                                        OptionBufferConstIter end,
                                        OpaqueDataTuple::LengthFieldType length_field_type) {
  boost::shared_ptr<OptionOpaqueDataTuples>
      option(new OptionOpaqueDataTuples(u, type, begin, end, length_field_type));

  return (option);
833}

835OptionPtr
836OptionDefinition::factoryFqdnList(Option::Universe u,
                                OptionBufferConstIter begin,
                                OptionBufferConstIter end) const {

  const std::vector<uint8_t> data(begin, end);
  if (data.empty()) {
      isc_throw(InvalidOptionValue, "FQDN list option has invalid length of 0")do { std::ostringstream oss__; oss__ << "FQDN list option has invalid length of 0"
; throw InvalidOptionValue("option_definition.cc", 842, oss__
.str().c_str()); } while (1);
  }
  InputBuffer in_buf(static_cast<const void*>(&data[0]), data.size());
  std::vector<uint8_t> out_buf;
  out_buf.reserve(data.size());
  while (in_buf.getPosition() < in_buf.getLength()) {
      // Reuse readFqdn and writeFqdn code but on the whole buffer
      // so the DNS name code handles compression for us.
      try {
          isc::dns::Name name(in_buf);
          isc::dns::LabelSequence labels(name);
          if (labels.getDataLength() > 0) {
              size_t read_len = 0;
              const uint8_t* label = labels.getData(&read_len);
              out_buf.insert(out_buf.end(), label, label + read_len);
          }
      } catch (const isc::Exception& ex) {
          isc_throw(InvalidOptionValue, ex.what())do { std::ostringstream oss__; oss__ << ex.what(); throw
 InvalidOptionValue("option_definition.cc", 859, oss__.str().
c_str()); } while (1);
      }
  }
  return OptionPtr(new OptionCustom(*this, u,
                                    out_buf.begin(), out_buf.end()));
864}

866OptionPtr
867OptionDefinition::factorySpecialFormatOption(Option::Universe u,
                                           OptionBufferConstIter begin,
                                           OptionBufferConstIter end,
                                           bool convenient_notation) const {
  if ((u == Option::V6) && haveSpace(DHCP6_OPTION_SPACE"dhcp6")) {
      switch (getCode()) {
      case D6O_IA_NA:
      case D6O_IA_PD:
          // Record of 3 uint32, no array.
          return (factoryIA6(getCode(), begin, end));

      case D6O_IAADDR:
          // Record of an IPv6 address followed by 2 uint32, no array.
          return (factoryIAAddr6(getCode(), begin, end));

      case D6O_IAPREFIX:
          // Record of 2 uint32, one uint8 and an IPv6 address, no array.
          return (factoryIAPrefix6(getCode(), begin, end));

      case D6O_CLIENT_FQDN:
          // Record of one uint8 and one FQDN, no array.
          return (OptionPtr(new Option6ClientFqdn(begin, end)));

      case D6O_VENDOR_OPTS:
          // Type uint32.
          // Vendor-Specific Information (option code 17).
          return (OptionPtr(new OptionVendor(Option::V6, begin, end)));

      case D6O_VENDOR_CLASS:
          // Record of one uint32 and one string.
          // Vendor Class (option code 16).
          return (OptionPtr(new OptionVendorClass(Option::V6, begin, end)));

      case D6O_STATUS_CODE:
          // Record of one uint16 and one string.
          // Status Code (option code 13).
          return (OptionPtr(new Option6StatusCode(begin, end)));

      case D6O_BOOTFILE_PARAM:
          // Array of tuples.
          // Bootfile params (option code 60).
          return (factoryOpaqueDataTuples(Option::V6, getCode(), begin, end));

      case D6O_PD_EXCLUDE:
          // Type IPv6 prefix.
          // Prefix Exclude (option code 67),
          return (OptionPtr(new Option6PDExclude(begin, end)));

      case D6O_V6_DNR:
          return (OptionPtr(new Option6Dnr(begin, end, convenient_notation)));

      default:
          break;
      }
  } else if ((u == Option::V4) && haveSpace(DHCP4_OPTION_SPACE"dhcp4")) {
      switch (getCode()) {
      case DHO_SERVICE_SCOPE:
          // Record of a boolean and a string.
          return (OptionPtr(new Option4SlpServiceScope(begin, end)));

      case DHO_FQDN:
          // Record of 3 uint8 and a FQDN, no array.
          return (OptionPtr(new Option4ClientFqdn(begin, end)));

      case DHO_CLASSLESS_STATIC_ROUTE:
          return (OptionPtr(new OptionClasslessStaticRoute(begin, end, convenient_notation)));

      case DHO_VIVCO_SUBOPTIONS:
          // Record of uint32 followed by binary.
          // V-I Vendor Class (option code 124).
          return (OptionPtr(new OptionVendorClass(Option::V4, begin, end)));

      case DHO_VIVSO_SUBOPTIONS:
          // Type uint32.
          // Vendor-Specific Information (option code 125).
          return (OptionPtr(new OptionVendor(Option::V4, begin, end)));

      case DHO_V4_SZTP_REDIRECT:
          // Array of tuples.
          // DHCPv4 SZTP Redirect Option (option code 143).
          return (factoryOpaqueDataTuples(Option::V4, getCode(), begin, end, OpaqueDataTuple::LENGTH_2_BYTES));

      case DHO_V4_DNR:
          return (OptionPtr(new Option4Dnr(begin, end, convenient_notation)));

      default:
          break;
      }
  }
  if ((u == Option::V4) && haveCompressedFqdnListFormat()) {
      return (factoryFqdnList(Option::V4, begin, end));
  }
  return (OptionPtr());
960}

962} // end of isc::dhcp namespace
963} // end of isc namespace

←

/usr/include/boost/algorithm/string/classification.hpp

→

1//  Boost string_algo library classification.hpp header file  ---------------------------//

3//  Copyright Pavol Droba 2002-2003.
4//
5// Distributed under the Boost Software License, Version 1.0.
6//    (See accompanying file LICENSE_1_0.txt or copy at
7//          http://www.boost.org/LICENSE_1_0.txt)

9//  See http://www.boost.org/ for updates, documentation, and revision history.

11#ifndef BOOST_STRING_CLASSIFICATION_HPP
12#define BOOST_STRING_CLASSIFICATION_HPP

14#include <algorithm>
15#include <locale>
16#include <boost/range/value_type.hpp>
17#include <boost/range/as_literal.hpp>
18#include <boost/algorithm/string/detail/classification.hpp>
19#include <boost/algorithm/string/predicate_facade.hpp>


22/*! \file
  Classification predicates are included in the library to give 
  some more convenience when using algorithms like \c trim() and \c all(). 
  They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
  into generic functors. 
27*/

29namespace boost {
  namespace algorithm {

32//  classification functor generator -------------------------------------//

      //! is_classified predicate
      /*!
          Construct the \c is_classified predicate. This predicate holds if the input is
          of specified \c std::ctype category.

          \param Type A \c std::ctype category
          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF
      is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(Type, Loc);
      }

      //! is_space predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::space category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate
      */
      inline detail::is_classifiedF 
      is_space(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::space, Loc);
      }

      //! is_alnum predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::alnum category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_alnum(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::alnum, Loc);
      }

      //! is_alpha predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::alpha category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_alpha(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::alpha, Loc);
      }

      //! is_cntrl predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::cntrl category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_cntrl(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
      }

      //! is_digit predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::digit category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_digit(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::digit, Loc);
      }

      //! is_graph predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::graph category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF
      is_graph(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::graph, Loc);
      }

      //! is_lower predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::lower category.   

          \param Loc A locale used for classification
          \return An instance of \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_lower(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::lower, Loc);
      }

      //! is_print predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::print category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_print(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::print, Loc);
      }

      //! is_punct predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::punct category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_punct(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::punct, Loc);
      }

      //! is_upper predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::upper category.   

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_upper(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::upper, Loc);
      }

      //! is_xdigit predicate
      /*!
          Construct the \c is_classified predicate for the \c ctype_base::xdigit category.  

          \param Loc A locale used for classification
          \return An instance of the \c is_classified predicate 
      */
      inline detail::is_classifiedF 
      is_xdigit(const std::locale& Loc=std::locale())
      {
          return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
      }

      //! is_any_of predicate
      /*!
          Construct the \c is_any_of predicate. The predicate holds if the input
          is included in the specified set of characters.

          \param Set A set of characters to be recognized
          \return An instance of the \c is_any_of predicate 
      */
      template<typename RangeT>
      inline detail::is_any_ofF<
          BOOST_STRING_TYPENAMEtypename range_value<RangeT>::type> 
      is_any_of( const RangeT& Set )
      {
          iterator_range<BOOST_STRING_TYPENAMEtypename range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
          return detail::is_any_ofF<BOOST_STRING_TYPENAMEtypename range_value<RangeT>::type>(lit_set); 
      }

      //! is_from_range predicate
      /*!
          Construct the \c is_from_range predicate. The predicate holds if the input
          is included in the specified range. (i.e. From <= Ch <= To )

          \param From The start of the range
          \param To The end of the range
          \return An instance of the \c is_from_range predicate 
      */
      template<typename CharT>
      inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
      {
          return detail::is_from_rangeF<CharT>(From,To); 
      }
      
      // predicate combinators ---------------------------------------------------//

      //! predicate 'and' composition predicate
      /*!
          Construct the \c class_and predicate. This predicate can be used
          to logically combine two classification predicates. \c class_and holds,
          if both predicates return true.

          \param Pred1 The first predicate
          \param Pred2 The second predicate
          \return An instance of the \c class_and predicate     
      */
      template<typename Pred1T, typename Pred2T>
      inline detail::pred_andF<Pred1T, Pred2T>
      operator&&( 
          const predicate_facade<Pred1T>& Pred1, 
          const predicate_facade<Pred2T>& Pred2 )
      {    
          // Doing the static_cast with the pointer instead of the reference
          // is a workaround for some compilers which have problems with
          // static_cast's of template references, i.e. CW8. /grafik/
          return detail::pred_andF<Pred1T,Pred2T>(
              *static_cast<const Pred1T*>(&Pred1), 
              *static_cast<const Pred2T*>(&Pred2) );
      }

      //! predicate 'or' composition predicate
      /*!
          Construct the \c class_or predicate. This predicate can be used
          to logically combine two classification predicates. \c class_or holds,
          if one of the predicates return true.

          \param Pred1 The first predicate
          \param Pred2 The second predicate
          \return An instance of the \c class_or predicate     
      */
      template<typename Pred1T, typename Pred2T>
      inline detail::pred_orF<Pred1T, Pred2T>
      operator||( 
          const predicate_facade<Pred1T>& Pred1, 
          const predicate_facade<Pred2T>& Pred2 )
      {    
          // Doing the static_cast with the pointer instead of the reference
          // is a workaround for some compilers which have problems with
          // static_cast's of template references, i.e. CW8. /grafik/
          return detail::pred_orF<Pred1T,Pred2T>(
              *static_cast<const Pred1T*>(&Pred1), 
              *static_cast<const Pred2T*>(&Pred2));
2
←
Calling copy constructor for 'is_any_ofF<char>'→
5
←
Returning from copy constructor for 'is_any_ofF<char>'→
6
←
Calling '~is_any_ofF'→
      }

      //! predicate negation operator
      /*!
          Construct the \c class_not predicate. This predicate represents a negation. 
          \c class_or holds if of the predicates return false.

          \param Pred The predicate to be negated
          \return An instance of the \c class_not predicate     
      */
      template<typename PredT>
      inline detail::pred_notF<PredT>
      operator!( const predicate_facade<PredT>& Pred )
      {
          // Doing the static_cast with the pointer instead of the reference
          // is a workaround for some compilers which have problems with
          // static_cast's of template references, i.e. CW8. /grafik/
          return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); 
      }

  } // namespace algorithm

  // pull names to the boost namespace
  using algorithm::is_classified;
  using algorithm::is_space;
  using algorithm::is_alnum;
  using algorithm::is_alpha;
  using algorithm::is_cntrl;
  using algorithm::is_digit;
  using algorithm::is_graph;
  using algorithm::is_lower;
  using algorithm::is_upper;
  using algorithm::is_print;
  using algorithm::is_punct;
  using algorithm::is_xdigit;
  using algorithm::is_any_of;
  using algorithm::is_from_range;

310} // namespace boost

312#endif  // BOOST_STRING_PREDICATE_HPP

←

/usr/include/boost/algorithm/string/detail/classification.hpp

1//  Boost string_algo library classification.hpp header file  ---------------------------//

3//  Copyright Pavol Droba 2002-2003.
4// 
5// Distributed under the Boost Software License, Version 1.0.
6//    (See accompanying file LICENSE_1_0.txt or copy at
7//          http://www.boost.org/LICENSE_1_0.txt)

9//  See http://www.boost.org/ for updates, documentation, and revision history.

11#ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
12#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP

14#include <boost/algorithm/string/config.hpp>
15#include <algorithm>
16#include <cstring>
17#include <functional>
18#include <locale>

20#include <boost/range/begin.hpp>
21#include <boost/range/distance.hpp>
22#include <boost/range/end.hpp>

24#include <boost/algorithm/string/predicate_facade.hpp>
25#include <boost/type_traits/remove_const.hpp>

27namespace boost {
  namespace algorithm {
      namespace detail {

31//  classification functors -----------------------------------------------//

 // is_classified functor
          struct is_classifiedF :
              public predicate_facade<is_classifiedF>
          {
              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor from a locale
              is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                  m_Type(Type), m_Locale(Loc) {}
              // Operation
              template<typename CharT>
              bool operator()( CharT Ch ) const
              {
                  return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
              }

              #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x582) && !defined(_USE_OLD_RW_STL)
                  template<>
                  bool operator()( char const Ch ) const
                  {
                      return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
                  }
              #endif

          private:
              std::ctype_base::mask m_Type;
              std::locale m_Locale;
          };


          // is_any_of functor
          /*
              returns true if the value is from the specified set
          */
          template<typename CharT>
          struct is_any_ofF :
              public predicate_facade<is_any_ofF<CharT> >
          {
          private:
              // set cannot operate on const value-type
              typedef typename ::boost::remove_const<CharT>::type set_value_type;

          public:     
              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor
              template<typename RangeT>
              is_any_ofF( const RangeT& Range ) : m_Size(0)
              {
                  // Prepare storage
                  m_Storage.m_dynSet=0;

                  std::size_t Size=::boost::distance(Range);
                  m_Size=Size;
                  set_value_type* Storage=0;

                  if(use_fixed_storage(m_Size))
                  {
                      // Use fixed storage
                      Storage=&m_Storage.m_fixSet[0];
                  }
                  else
                  {
                      // Use dynamic storage
                      m_Storage.m_dynSet=new set_value_type[m_Size];
                      Storage=m_Storage.m_dynSet;
                  }

                  // Use fixed storage
                  ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
                  ::std::sort(Storage, Storage+m_Size);
              }

              // Copy constructor
              is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
              {
                  // Prepare storage
                  m_Storage.m_dynSet=0;               
                  const set_value_type* SrcStorage=0;
                  set_value_type* DestStorage=0;

                  if(use_fixed_storage(m_Size))
3
←
Taking false branch→
                  {
                      // Use fixed storage
                      DestStorage=&m_Storage.m_fixSet[0];
                      SrcStorage=&Other.m_Storage.m_fixSet[0];
                  }
                  else
                  {
                      // Use dynamic storage
                      m_Storage.m_dynSet=new set_value_type[m_Size];
4
←
Memory is allocated→
                      DestStorage=m_Storage.m_dynSet;
                      SrcStorage=Other.m_Storage.m_dynSet;
                  }

                  // Use fixed storage
                  ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
              }

              // Destructor
              ~is_any_ofF()
              {
                  if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                  {
                      delete [] m_Storage.m_dynSet;
                  }
              }
7
←
Potential memory leak

              // Assignment
              is_any_ofF& operator=(const is_any_ofF& Other)
              {
                  // Handle self assignment
                  if(this==&Other) return *this;

                  // Prepare storage             
                  const set_value_type* SrcStorage;
                  set_value_type* DestStorage;

                  if(use_fixed_storage(Other.m_Size))
                  {
                      // Use fixed storage
                      DestStorage=&m_Storage.m_fixSet[0];
                      SrcStorage=&Other.m_Storage.m_fixSet[0];

                      // Delete old storage if was present
                      if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                      {
                          delete [] m_Storage.m_dynSet;
                      }

                      // Set new size
                      m_Size=Other.m_Size;
                  }
                  else
                  {
                      // Other uses dynamic storage
                      SrcStorage=Other.m_Storage.m_dynSet;

                      // Check what kind of storage are we using right now
                      if(use_fixed_storage(m_Size))
                      {
                          // Using fixed storage, allocate new
                          set_value_type* pTemp=new set_value_type[Other.m_Size];
                          DestStorage=pTemp;
                          m_Storage.m_dynSet=pTemp;
                          m_Size=Other.m_Size;
                      }
                      else
                      {
                          // Using dynamic storage, check if can reuse
                          if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
                          {
                              // Reuse the current storage
                              DestStorage=m_Storage.m_dynSet;
                              m_Size=Other.m_Size;
                          }
                          else
                          {
                              // Allocate the new one
                              set_value_type* pTemp=new set_value_type[Other.m_Size];
                              DestStorage=pTemp;
                      
                              // Delete old storage if necessary
                              if(m_Storage.m_dynSet!=0)
                              {
                                  delete [] m_Storage.m_dynSet;
                              }
                              // Store the new storage
                              m_Storage.m_dynSet=pTemp;
                              // Set new size
                              m_Size=Other.m_Size;
                          }
                      }
                  }

                  // Copy the data
                  ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);

                  return *this;
              }

              // Operation
              template<typename Char2T>
              bool operator()( Char2T Ch ) const
              {
                  const set_value_type* Storage=
                      (use_fixed_storage(m_Size))
                      ? &m_Storage.m_fixSet[0]
                      : m_Storage.m_dynSet;

                  return ::std::binary_search(Storage, Storage+m_Size, Ch);
              }
          private:
              // check if the size is eligible for fixed storage
              static bool use_fixed_storage(std::size_t size)
              {
                  return size<=sizeof(set_value_type*)*2;
              }


          private:
              // storage
              // The actual used storage is selected on the type
              union
              {
                  set_value_type* m_dynSet;
                  set_value_type m_fixSet[sizeof(set_value_type*)*2];
              } 
              m_Storage;
      
              // storage size
              ::std::size_t m_Size;
          };

          // is_from_range functor
          /*
              returns true if the value is from the specified range.
              (i.e. x>=From && x>=To)
          */
          template<typename CharT>
          struct is_from_rangeF :
              public predicate_facade< is_from_rangeF<CharT> >
          {
              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor
              is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}

              // Operation
              template<typename Char2T>
              bool operator()( Char2T Ch ) const
              {
                  return ( m_From <= Ch ) && ( Ch <= m_To );
              }

          private:
              CharT m_From;
              CharT m_To;
          };

          // class_and composition predicate
          template<typename Pred1T, typename Pred2T>
          struct pred_andF :
              public predicate_facade< pred_andF<Pred1T,Pred2T> >
          {
          public:

              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor
              pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
                  m_Pred1(Pred1), m_Pred2(Pred2) {}

              // Operation
              template<typename CharT>
              bool operator()( CharT Ch ) const
              {
                  return m_Pred1(Ch) && m_Pred2(Ch);
              }

          private:
              Pred1T m_Pred1;
              Pred2T m_Pred2;
          };

          // class_or composition predicate
          template<typename Pred1T, typename Pred2T>
          struct pred_orF :
              public predicate_facade< pred_orF<Pred1T,Pred2T> >
          {
          public:
              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor
              pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
                  m_Pred1(Pred1), m_Pred2(Pred2) {}

              // Operation
              template<typename CharT>
              bool operator()( CharT Ch ) const
              {
                  return m_Pred1(Ch) || m_Pred2(Ch);
              }

          private:
              Pred1T m_Pred1;
              Pred2T m_Pred2;
          };

          // class_not composition predicate
          template< typename PredT >
          struct pred_notF :
              public predicate_facade< pred_notF<PredT> >
          {
          public:
              // Boost.ResultOf support
              typedef bool result_type;

              // Constructor
              pred_notF( PredT Pred ) : m_Pred(Pred) {}

              // Operation
              template<typename CharT>
              bool operator()( CharT Ch ) const
              {
                  return !m_Pred(Ch);
              }

          private:
              PredT m_Pred;
          };

      } // namespace detail
  } // namespace algorithm
352} // namespace boost


355#endif  // BOOST_STRING_CLASSIFICATION_DETAIL_HPP