json_config_parser.cc 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805
  1. // Copyright (C) 2012-2014 Internet Systems Consortium, Inc. ("ISC")
  2. //
  3. // Permission to use, copy, modify, and/or distribute this software for any
  4. // purpose with or without fee is hereby granted, provided that the above
  5. // copyright notice and this permission notice appear in all copies.
  6. //
  7. // THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  8. // REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  9. // AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  10. // INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  11. // LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  12. // OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  13. // PERFORMANCE OF THIS SOFTWARE.
  14. #include <asiolink/io_address.h>
  15. #include <cc/data.h>
  16. #include <config/ccsession.h>
  17. #include <dhcp/libdhcp++.h>
  18. #include <dhcp6/json_config_parser.h>
  19. #include <dhcp6/dhcp6_log.h>
  20. #include <dhcp/iface_mgr.h>
  21. #include <dhcpsrv/cfg_option.h>
  22. #include <dhcpsrv/cfgmgr.h>
  23. #include <dhcpsrv/pool.h>
  24. #include <dhcpsrv/subnet.h>
  25. #include <dhcpsrv/triplet.h>
  26. #include <dhcpsrv/parsers/dbaccess_parser.h>
  27. #include <dhcpsrv/parsers/dhcp_config_parser.h>
  28. #include <dhcpsrv/parsers/dhcp_parsers.h>
  29. #include <dhcpsrv/parsers/host_reservation_parser.h>
  30. #include <dhcpsrv/parsers/host_reservations_list_parser.h>
  31. #include <log/logger_support.h>
  32. #include <util/encode/hex.h>
  33. #include <util/strutil.h>
  34. #include <boost/algorithm/string.hpp>
  35. #include <boost/foreach.hpp>
  36. #include <boost/lexical_cast.hpp>
  37. #include <boost/scoped_ptr.hpp>
  38. #include <boost/shared_ptr.hpp>
  39. #include <iostream>
  40. #include <map>
  41. #include <vector>
  42. #include <stdint.h>
  43. using namespace std;
  44. using namespace isc;
  45. using namespace isc::data;
  46. using namespace isc::dhcp;
  47. using namespace isc::asiolink;
  48. namespace {
  49. // Pointers to various parser objects.
  50. typedef boost::shared_ptr<BooleanParser> BooleanParserPtr;
  51. typedef boost::shared_ptr<StringParser> StringParserPtr;
  52. typedef boost::shared_ptr<Uint32Parser> Uint32ParserPtr;
  53. /// @brief Parser for IPv6 pool definitions.
  54. ///
  55. /// This is the IPv6 derivation of the PoolParser class and handles pool
  56. /// definitions, i.e. a list of entries of one of two syntaxes: min-max and
  57. /// prefix/len for IPv6 pools. Pool6 objects are created and stored in chosen
  58. /// PoolStorage container.
  59. ///
  60. /// It is useful for parsing Dhcp6/subnet6[X]/pool parameters.
  61. class Pool6Parser : public PoolParser {
  62. public:
  63. /// @brief Constructor.
  64. ///
  65. /// @param param_name name of the parameter. Note, it is passed through
  66. /// but unused, parameter is currently always "Dhcp6/subnet6[X]/pool"
  67. /// @param pools storage container in which to store the parsed pool
  68. /// upon "commit"
  69. Pool6Parser(const std::string& param_name, PoolStoragePtr pools)
  70. :PoolParser(param_name, pools) {
  71. }
  72. protected:
  73. /// @brief Creates a Pool6 object given a IPv6 prefix and the prefix length.
  74. ///
  75. /// @param addr is the IPv6 prefix of the pool.
  76. /// @param len is the prefix length.
  77. /// @param ptype is the type of IPv6 pool (Pool::PoolType). Note this is
  78. /// passed in as an int32_t and cast to PoolType to accommodate a
  79. /// polymorphic interface.
  80. /// @return returns a PoolPtr to the new Pool4 object.
  81. PoolPtr poolMaker (IOAddress &addr, uint32_t len, int32_t ptype)
  82. {
  83. return (PoolPtr(new Pool6(static_cast<isc::dhcp::Lease::Type>
  84. (ptype), addr, len)));
  85. }
  86. /// @brief Creates a Pool6 object given starting and ending IPv6 addresses.
  87. ///
  88. /// @param min is the first IPv6 address in the pool.
  89. /// @param max is the last IPv6 address in the pool.
  90. /// @param ptype is the type of IPv6 pool (Pool::PoolType). Note this is
  91. /// passed in as an int32_t and cast to PoolType to accommodate a
  92. /// polymorphic interface.
  93. /// @return returns a PoolPtr to the new Pool4 object.
  94. PoolPtr poolMaker (IOAddress &min, IOAddress &max, int32_t ptype)
  95. {
  96. return (PoolPtr(new Pool6(static_cast<isc::dhcp::Lease::Type>
  97. (ptype), min, max)));
  98. }
  99. };
  100. class Pools6ListParser : public PoolsListParser {
  101. public:
  102. Pools6ListParser(const std::string& dummy, PoolStoragePtr pools)
  103. :PoolsListParser(dummy, pools) {
  104. }
  105. protected:
  106. virtual ParserPtr poolParserMaker(PoolStoragePtr storage) {
  107. return (ParserPtr(new Pool6Parser("pool", storage)));
  108. }
  109. };
  110. /// @brief Parser for IPv6 prefix delegation definitions.
  111. ///
  112. /// This class handles prefix delegation pool definitions for IPv6 subnets
  113. /// Pool6 objects are created and stored in the given PoolStorage container.
  114. ///
  115. /// PdPool defintions currently support three elements: prefix, prefix-len,
  116. /// and delegated-len, as shown in the example JSON text below:
  117. ///
  118. /// @code
  119. ///
  120. /// {
  121. /// "prefix": "2001:db8:1::",
  122. /// "prefix-len": 64,
  123. /// "delegated-len": 128
  124. /// }
  125. /// @endcode
  126. ///
  127. class PdPoolParser : public DhcpConfigParser {
  128. public:
  129. /// @brief Constructor.
  130. ///
  131. /// @param param_name name of the parameter. Note, it is passed through
  132. /// but unused, parameter is currently always "Dhcp6/subnet6[X]/pool"
  133. /// @param pools storage container in which to store the parsed pool
  134. /// upon "commit"
  135. PdPoolParser(const std::string&, PoolStoragePtr pools)
  136. : uint32_values_(new Uint32Storage()),
  137. string_values_(new StringStorage()), pools_(pools) {
  138. if (!pools_) {
  139. isc_throw(isc::dhcp::DhcpConfigError,
  140. "PdPoolParser context storage may not be NULL");
  141. }
  142. }
  143. /// @brief Builds a prefix delegation pool from the given configuration
  144. ///
  145. /// This function parses configuration entries and creates an instance
  146. /// of a dhcp::Pool6 configured for prefix delegation.
  147. ///
  148. /// @param pd_pool_ pointer to an element that holds configuration entries
  149. /// that define a prefix delegation pool.
  150. ///
  151. /// @throw DhcpConfigError if configuration parsing fails.
  152. virtual void build(ConstElementPtr pd_pool_) {
  153. // Parse the elements that make up the option definition.
  154. BOOST_FOREACH(ConfigPair param, pd_pool_->mapValue()) {
  155. std::string entry(param.first);
  156. ParserPtr parser;
  157. if (entry == "prefix") {
  158. StringParserPtr str_parser(new StringParser(entry,
  159. string_values_));
  160. parser = str_parser;
  161. } else if (entry == "prefix-len" || entry == "delegated-len") {
  162. Uint32ParserPtr code_parser(new Uint32Parser(entry,
  163. uint32_values_));
  164. parser = code_parser;
  165. } else {
  166. isc_throw(DhcpConfigError, "unsupported parameter: " << entry
  167. << " (" << param.second->getPosition() << ")");
  168. }
  169. parser->build(param.second);
  170. parser->commit();
  171. }
  172. // Try to obtain the pool parameters. It will throw an exception if any
  173. // of the required parameters are not present or invalid.
  174. std::string addr_str;
  175. uint32_t prefix_len;
  176. uint32_t delegated_len;
  177. try {
  178. addr_str = string_values_->getParam("prefix");
  179. prefix_len = uint32_values_->getParam("prefix-len");
  180. delegated_len = uint32_values_->getParam("delegated-len");
  181. // Attempt to construct the local pool.
  182. pool_.reset(new Pool6(Lease::TYPE_PD, IOAddress(addr_str),
  183. prefix_len, delegated_len));
  184. } catch (const std::exception& ex) {
  185. // Some parameters don't exist or are invalid. Since we are not
  186. // aware whether they don't exist or are invalid, let's append
  187. // the position of the pool map element.
  188. isc_throw(isc::dhcp::DhcpConfigError, ex.what()
  189. << " (" << pd_pool_->getPosition() << ")");
  190. }
  191. }
  192. // @brief Commits the constructed local pool to the pool storage.
  193. virtual void commit() {
  194. // Add the local pool to the external storage ptr.
  195. pools_->push_back(pool_);
  196. }
  197. protected:
  198. /// Storage for subnet-specific integer values.
  199. Uint32StoragePtr uint32_values_;
  200. /// Storage for subnet-specific string values.
  201. StringStoragePtr string_values_;
  202. /// Parsers are stored here.
  203. ParserCollection parsers_;
  204. /// Pointer to the created pool object.
  205. isc::dhcp::Pool6Ptr pool_;
  206. /// Pointer to storage to which the local pool is written upon commit.
  207. isc::dhcp::PoolStoragePtr pools_;
  208. };
  209. /// @brief Parser for a list of prefix delegation pools.
  210. ///
  211. /// This parser iterates over a list of prefix delegation pool entries and
  212. /// creates pool instances for each one. If the parsing is successful, the
  213. /// collection of pools is committed to the provided storage.
  214. class PdPoolListParser : public DhcpConfigParser {
  215. public:
  216. /// @brief Constructor.
  217. ///
  218. /// @param dummy first argument is ignored, all Parser constructors
  219. /// accept string as first argument.
  220. /// @param storage is the pool storage in which to store the parsed
  221. /// pools in this list
  222. /// @throw isc::dhcp::DhcpConfigError if storage is null.
  223. PdPoolListParser(const std::string&, PoolStoragePtr pools)
  224. : local_pools_(new PoolStorage()), pools_(pools) {
  225. if (!pools_) {
  226. isc_throw(isc::dhcp::DhcpConfigError,
  227. "PdPoolListParser pools storage may not be NULL");
  228. }
  229. }
  230. /// @brief Parse configuration entries.
  231. ///
  232. /// This function parses configuration entries and creates instances
  233. /// of prefix delegation pools .
  234. ///
  235. /// @param pd_pool_list pointer to an element that holds entries
  236. /// that define a prefix delegation pool.
  237. ///
  238. /// @throw DhcpConfigError if configuration parsing fails.
  239. void build(isc::data::ConstElementPtr pd_pool_list) {
  240. // Make sure the local list is empty.
  241. local_pools_.reset(new PoolStorage());
  242. // Make sure we have a configuration elements to parse.
  243. if (!pd_pool_list) {
  244. isc_throw(DhcpConfigError,
  245. "PdPoolListParser: list of pool definitions is NULL");
  246. }
  247. // Loop through the list of pd pools.
  248. BOOST_FOREACH(ConstElementPtr pd_pool, pd_pool_list->listValue()) {
  249. boost::shared_ptr<PdPoolParser>
  250. // Create the PdPool parser.
  251. parser(new PdPoolParser("pd-pool", local_pools_));
  252. // Build the pool instance
  253. parser->build(pd_pool);
  254. // Commit the pool to the local list of pools.
  255. parser->commit();
  256. }
  257. }
  258. /// @brief Commits the pools created to the external storage area.
  259. ///
  260. /// Note that this method adds the local list of pools to the storage area
  261. /// rather than replacing its contents. This permits other parsers to
  262. /// contribute to the set of pools.
  263. void commit() {
  264. // local_pools_ holds the values produced by the build function.
  265. // At this point parsing should have completed successfully so
  266. // we can append new data to the supplied storage.
  267. pools_->insert(pools_->end(), local_pools_->begin(),
  268. local_pools_->end());
  269. }
  270. private:
  271. /// @brief storage for local pools
  272. PoolStoragePtr local_pools_;
  273. /// @brief External storage where pools are stored upon list commit.
  274. PoolStoragePtr pools_;
  275. };
  276. /// @brief This class parses a single IPv6 subnet.
  277. ///
  278. /// This is the IPv6 derivation of the SubnetConfigParser class and it parses
  279. /// the whole subnet definition. It creates parsersfor received configuration
  280. /// parameters as needed.
  281. class Subnet6ConfigParser : public SubnetConfigParser {
  282. public:
  283. /// @brief Constructor
  284. ///
  285. /// @param ignored first parameter
  286. /// stores global scope parameters, options, option defintions.
  287. Subnet6ConfigParser(const std::string&)
  288. :SubnetConfigParser("", globalContext(), IOAddress("::")) {
  289. }
  290. /// @brief Parses a single IPv4 subnet configuration and adds to the
  291. /// Configuration Manager.
  292. ///
  293. /// @param subnet A new subnet being configured.
  294. void build(ConstElementPtr subnet) {
  295. SubnetConfigParser::build(subnet);
  296. if (subnet_) {
  297. Subnet6Ptr sub6ptr = boost::dynamic_pointer_cast<Subnet6>(subnet_);
  298. if (!sub6ptr) {
  299. // If we hit this, it is a programming error.
  300. isc_throw(Unexpected,
  301. "Invalid cast in Subnet6ConfigParser::commit");
  302. }
  303. // Set relay infomation if it was provided
  304. if (relay_info_) {
  305. sub6ptr->setRelayInfo(*relay_info_);
  306. }
  307. // Adding a subnet to the Configuration Manager may fail if the
  308. // subnet id is invalid (duplicate). Thus, we catch exceptions
  309. // here to append a position in the configuration string.
  310. try {
  311. CfgMgr::instance().getStagingCfg()->getCfgSubnets6()->add(sub6ptr);
  312. } catch (const std::exception& ex) {
  313. isc_throw(DhcpConfigError, ex.what() << " ("
  314. << subnet->getPosition() << ")");
  315. }
  316. // Parse Host Reservations for this subnet if any.
  317. ConstElementPtr reservations = subnet->get("reservations");
  318. if (reservations) {
  319. ParserPtr parser(new HostReservationsListParser<
  320. HostReservationParser6>(subnet_->getID()));
  321. parser->build(reservations);
  322. }
  323. }
  324. }
  325. /// @brief Commits subnet configuration.
  326. ///
  327. /// This function is currently no-op because subnet should already
  328. /// be added into the Config Manager in the build().
  329. void commit() { }
  330. protected:
  331. /// @brief creates parsers for entries in subnet definition
  332. ///
  333. /// @param config_id name of the entry
  334. ///
  335. /// @return parser object for specified entry name. Note the caller is
  336. /// responsible for deleting the parser created.
  337. /// @throw isc::dhcp::DhcpConfigError if trying to create a parser
  338. /// for unknown config element
  339. DhcpConfigParser* createSubnetConfigParser(const std::string& config_id) {
  340. DhcpConfigParser* parser = NULL;
  341. if ((config_id.compare("preferred-lifetime") == 0) ||
  342. (config_id.compare("valid-lifetime") == 0) ||
  343. (config_id.compare("renew-timer") == 0) ||
  344. (config_id.compare("rebind-timer") == 0) ||
  345. (config_id.compare("id") == 0)) {
  346. parser = new Uint32Parser(config_id, uint32_values_);
  347. } else if ((config_id.compare("subnet") == 0) ||
  348. (config_id.compare("interface") == 0) ||
  349. (config_id.compare("client-class") == 0) ||
  350. (config_id.compare("interface-id") == 0)) {
  351. parser = new StringParser(config_id, string_values_);
  352. } else if (config_id.compare("pools") == 0) {
  353. parser = new Pools6ListParser(config_id, pools_);
  354. } else if (config_id.compare("relay") == 0) {
  355. parser = new RelayInfoParser(config_id, relay_info_, Option::V6);
  356. } else if (config_id.compare("pd-pools") == 0) {
  357. parser = new PdPoolListParser(config_id, pools_);
  358. } else if (config_id.compare("option-data") == 0) {
  359. parser = new OptionDataListParser(config_id, options_, AF_INET6);
  360. } else {
  361. isc_throw(NotImplemented, "unsupported parameter: " << config_id);
  362. }
  363. return (parser);
  364. }
  365. /// @brief Determines if the given option space name and code describe
  366. /// a standard option for the DHCP6 server.
  367. ///
  368. /// @param option_space is the name of the option space to consider
  369. /// @param code is the numeric option code to consider
  370. /// @return returns true if the space and code are part of the server's
  371. /// standard options.
  372. bool isServerStdOption(std::string option_space, uint32_t code) {
  373. return ((option_space.compare("dhcp6") == 0)
  374. && LibDHCP::isStandardOption(Option::V6, code));
  375. }
  376. /// @brief Returns the option definition for a given option code from
  377. /// the DHCP6 server's standard set of options.
  378. /// @param code is the numeric option code of the desired option definition.
  379. /// @return returns a pointer the option definition
  380. OptionDefinitionPtr getServerStdOptionDefinition (uint32_t code) {
  381. return (LibDHCP::getOptionDef(Option::V6, code));
  382. }
  383. /// @brief Issues a DHCP6 server specific warning regarding duplicate subnet
  384. /// options.
  385. ///
  386. /// @param code is the numeric option code of the duplicate option
  387. /// @param addr is the subnet address
  388. /// @todo A means to know the correct logger and perhaps a common
  389. /// message would allow this message to be emitted by the base class.
  390. virtual void duplicate_option_warning(uint32_t code,
  391. isc::asiolink::IOAddress& addr) {
  392. LOG_WARN(dhcp6_logger, DHCP6_CONFIG_OPTION_DUPLICATE)
  393. .arg(code).arg(addr.toText());
  394. }
  395. /// @brief Instantiates the IPv6 Subnet based on a given IPv6 address
  396. /// and prefix length.
  397. ///
  398. /// @param addr is IPv6 prefix of the subnet.
  399. /// @param len is the prefix length
  400. void initSubnet(isc::asiolink::IOAddress addr, uint8_t len) {
  401. // Get all 'time' parameters using inheritance.
  402. // If the subnet-specific value is defined then use it, else
  403. // use the global value. The global value must always be
  404. // present. If it is not, it is an internal error and exception
  405. // is thrown.
  406. Triplet<uint32_t> t1 = getParam("renew-timer");
  407. Triplet<uint32_t> t2 = getParam("rebind-timer");
  408. Triplet<uint32_t> pref = getParam("preferred-lifetime");
  409. Triplet<uint32_t> valid = getParam("valid-lifetime");
  410. // Subnet ID is optional. If it is not supplied the value of 0 is used,
  411. // which means autogenerate.
  412. SubnetID subnet_id =
  413. static_cast<SubnetID>(uint32_values_->getOptionalParam("id", 0));
  414. // Get interface-id option content. For now we support string
  415. // represenation only
  416. std::string ifaceid;
  417. try {
  418. ifaceid = string_values_->getParam("interface-id");
  419. } catch (const DhcpConfigError &) {
  420. // interface-id is not mandatory
  421. }
  422. // Specifying both interface for locally reachable subnets and
  423. // interface id for relays is mutually exclusive. Need to test for
  424. // this condition.
  425. if (!ifaceid.empty()) {
  426. std::string iface;
  427. try {
  428. iface = string_values_->getParam("interface");
  429. } catch (const DhcpConfigError &) {
  430. // iface not mandatory
  431. }
  432. if (!iface.empty()) {
  433. isc_throw(isc::dhcp::DhcpConfigError,
  434. "parser error: interface (defined for locally reachable "
  435. "subnets) and interface-id (defined for subnets reachable"
  436. " via relays) cannot be defined at the same time for "
  437. "subnet " << addr << "/" << (int)len);
  438. }
  439. }
  440. stringstream tmp;
  441. tmp << addr << "/" << static_cast<int>(len)
  442. << " with params t1=" << t1 << ", t2=" << t2 << ", pref="
  443. << pref << ", valid=" << valid;
  444. LOG_INFO(dhcp6_logger, DHCP6_CONFIG_NEW_SUBNET).arg(tmp.str());
  445. // Create a new subnet.
  446. Subnet6* subnet6 = new Subnet6(addr, len, t1, t2, pref, valid,
  447. subnet_id);
  448. // Configure interface-id for remote interfaces, if defined
  449. if (!ifaceid.empty()) {
  450. OptionBuffer tmp(ifaceid.begin(), ifaceid.end());
  451. OptionPtr opt(new Option(Option::V6, D6O_INTERFACE_ID, tmp));
  452. subnet6->setInterfaceId(opt);
  453. }
  454. // Try setting up client class (if specified)
  455. try {
  456. string client_class = string_values_->getParam("client-class");
  457. subnet6->allowClientClass(client_class);
  458. } catch (const DhcpConfigError&) {
  459. // That's ok if it fails. client-class is optional.
  460. }
  461. subnet_.reset(subnet6);
  462. }
  463. };
  464. /// @brief this class parses a list of DHCP6 subnets
  465. ///
  466. /// This is a wrapper parser that handles the whole list of Subnet6
  467. /// definitions. It iterates over all entries and creates Subnet6ConfigParser
  468. /// for each entry.
  469. class Subnets6ListConfigParser : public DhcpConfigParser {
  470. public:
  471. /// @brief constructor
  472. ///
  473. /// @param dummy first argument, always ignored. All parsers accept a
  474. /// string parameter "name" as their first argument.
  475. Subnets6ListConfigParser(const std::string&) {
  476. }
  477. /// @brief parses contents of the list
  478. ///
  479. /// Iterates over all entries on the list and creates a Subnet6ConfigParser
  480. /// for each entry.
  481. ///
  482. /// @param subnets_list pointer to a list of IPv6 subnets
  483. void build(ConstElementPtr subnets_list) {
  484. BOOST_FOREACH(ConstElementPtr subnet, subnets_list->listValue()) {
  485. ParserPtr parser(new Subnet6ConfigParser("subnet"));
  486. parser->build(subnet);
  487. subnets_.push_back(parser);
  488. }
  489. }
  490. /// @brief commits subnets definitions.
  491. ///
  492. /// Iterates over all Subnet6 parsers. Each parser contains definitions of
  493. /// a single subnet and its parameters and commits each subnet separately.
  494. void commit() {
  495. BOOST_FOREACH(ParserPtr subnet, subnets_) {
  496. subnet->commit();
  497. }
  498. }
  499. /// @brief Returns Subnet6ListConfigParser object
  500. /// @param param_name name of the parameter
  501. /// @return Subnets6ListConfigParser object
  502. static DhcpConfigParser* factory(const std::string& param_name) {
  503. return (new Subnets6ListConfigParser(param_name));
  504. }
  505. /// @brief collection of subnet parsers.
  506. ParserCollection subnets_;
  507. };
  508. } // anonymous namespace
  509. namespace isc {
  510. namespace dhcp {
  511. /// @brief creates global parsers
  512. ///
  513. /// This method creates global parsers that parse global parameters, i.e.
  514. /// those that take format of Dhcp6/param1, Dhcp6/param2 and so forth.
  515. ///
  516. /// @param config_id pointer to received global configuration entry
  517. /// @return parser for specified global DHCPv6 parameter
  518. /// @throw NotImplemented if trying to create a parser for unknown config
  519. /// element
  520. DhcpConfigParser* createGlobal6DhcpConfigParser(const std::string& config_id,
  521. ConstElementPtr element) {
  522. DhcpConfigParser* parser = NULL;
  523. if ((config_id.compare("preferred-lifetime") == 0) ||
  524. (config_id.compare("valid-lifetime") == 0) ||
  525. (config_id.compare("renew-timer") == 0) ||
  526. (config_id.compare("rebind-timer") == 0)) {
  527. parser = new Uint32Parser(config_id,
  528. globalContext()->uint32_values_);
  529. } else if (config_id.compare("interfaces") == 0) {
  530. parser = new InterfaceListConfigParser(config_id, globalContext());
  531. } else if (config_id.compare("subnet6") == 0) {
  532. parser = new Subnets6ListConfigParser(config_id);
  533. } else if (config_id.compare("option-data") == 0) {
  534. parser = new OptionDataListParser(config_id, CfgOptionPtr(), AF_INET6);
  535. } else if (config_id.compare("option-def") == 0) {
  536. parser = new OptionDefListParser(config_id, globalContext());
  537. } else if (config_id.compare("version") == 0) {
  538. parser = new StringParser(config_id,
  539. globalContext()->string_values_);
  540. } else if (config_id.compare("lease-database") == 0) {
  541. parser = new DbAccessParser(config_id, *globalContext());
  542. } else if (config_id.compare("hooks-libraries") == 0) {
  543. parser = new HooksLibrariesParser(config_id);
  544. } else if (config_id.compare("dhcp-ddns") == 0) {
  545. parser = new D2ClientConfigParser(config_id);
  546. } else if (config_id.compare("mac-sources") == 0) {
  547. parser = new MACSourcesListConfigParser(config_id,
  548. globalContext());
  549. } else {
  550. isc_throw(DhcpConfigError,
  551. "unsupported global configuration parameter: "
  552. << config_id << " (" << element->getPosition() << ")");
  553. }
  554. return (parser);
  555. }
  556. isc::data::ConstElementPtr
  557. configureDhcp6Server(Dhcpv6Srv&, isc::data::ConstElementPtr config_set) {
  558. if (!config_set) {
  559. ConstElementPtr answer = isc::config::createAnswer(1,
  560. string("Can't parse NULL config"));
  561. return (answer);
  562. }
  563. LOG_DEBUG(dhcp6_logger, DBG_DHCP6_COMMAND,
  564. DHCP6_CONFIG_START).arg(config_set->str());
  565. // Before starting any subnet operations, let's reset the subnet-id counter,
  566. // so newly recreated configuration starts with first subnet-id equal 1.
  567. Subnet::resetSubnetID();
  568. // Some of the values specified in the configuration depend on
  569. // other values. Typically, the values in the subnet6 structure
  570. // depend on the global values. Also, option values configuration
  571. // must be performed after the option definitions configurations.
  572. // Thus we group parsers and will fire them in the right order:
  573. // all parsers other than subnet6 and option-data parser,
  574. // option-data parser, subnet6 parser.
  575. ParserCollection independent_parsers;
  576. ParserPtr subnet_parser;
  577. ParserPtr option_parser;
  578. ParserPtr iface_parser;
  579. // Some of the parsers alter state of the system that can't easily
  580. // be undone. (Or alter it in a way such that undoing the change
  581. // has the same risk of failure as doing the change.)
  582. ParserPtr hooks_parser;
  583. // The subnet parsers implement data inheritance by directly
  584. // accessing global storage. For this reason the global data
  585. // parsers must store the parsed data into global storages
  586. // immediately. This may cause data inconsistency if the
  587. // parsing operation fails after the global storage has been
  588. // modified. We need to preserve the original global data here
  589. // so as we can rollback changes when an error occurs.
  590. ParserContext original_context(*globalContext());
  591. // answer will hold the result.
  592. ConstElementPtr answer;
  593. // rollback informs whether error occured and original data
  594. // have to be restored to global storages.
  595. bool rollback = false;
  596. // config_pair holds ther details of the current parser when iterating over
  597. // the parsers. It is declared outside the loop so in case of error, the
  598. // name of the failing parser can be retrieved within the "catch" clause.
  599. ConfigPair config_pair;
  600. try {
  601. // Make parsers grouping.
  602. const std::map<std::string, ConstElementPtr>& values_map =
  603. config_set->mapValue();
  604. BOOST_FOREACH(config_pair, values_map) {
  605. ParserPtr parser(createGlobal6DhcpConfigParser(config_pair.first,
  606. config_pair.second));
  607. LOG_DEBUG(dhcp6_logger, DBG_DHCP6_DETAIL, DHCP6_PARSER_CREATED)
  608. .arg(config_pair.first);
  609. if (config_pair.first == "subnet6") {
  610. subnet_parser = parser;
  611. } else if (config_pair.first == "option-data") {
  612. option_parser = parser;
  613. } else if (config_pair.first == "hooks-libraries") {
  614. // Executing the commit will alter currently loaded hooks
  615. // libraries. Check if the supplied libraries are valid,
  616. // but defer the commit until after everything else has
  617. // committed.
  618. hooks_parser = parser;
  619. hooks_parser->build(config_pair.second);
  620. } else if (config_pair.first == "interfaces") {
  621. // The interface parser is independent from any other parser and
  622. // can be run here before other parsers.
  623. parser->build(config_pair.second);
  624. iface_parser = parser;
  625. } else {
  626. // Those parsers should be started before other
  627. // parsers so we can call build straight away.
  628. independent_parsers.push_back(parser);
  629. parser->build(config_pair.second);
  630. // The commit operation here may modify the global storage
  631. // but we need it so as the subnet6 parser can access the
  632. // parsed data.
  633. parser->commit();
  634. }
  635. }
  636. // The option values parser is the next one to be run.
  637. std::map<std::string, ConstElementPtr>::const_iterator option_config =
  638. values_map.find("option-data");
  639. if (option_config != values_map.end()) {
  640. config_pair.first = "option-data";
  641. option_parser->build(option_config->second);
  642. option_parser->commit();
  643. }
  644. // The subnet parser is the last one to be run.
  645. std::map<std::string, ConstElementPtr>::const_iterator subnet_config =
  646. values_map.find("subnet6");
  647. if (subnet_config != values_map.end()) {
  648. config_pair.first = "subnet6";
  649. subnet_parser->build(subnet_config->second);
  650. }
  651. } catch (const isc::Exception& ex) {
  652. LOG_ERROR(dhcp6_logger, DHCP6_PARSER_FAIL)
  653. .arg(config_pair.first).arg(ex.what());
  654. answer = isc::config::createAnswer(1, ex.what());
  655. // An error occured, so make sure that we restore original data.
  656. rollback = true;
  657. } catch (...) {
  658. // for things like bad_cast in boost::lexical_cast
  659. LOG_ERROR(dhcp6_logger, DHCP6_PARSER_EXCEPTION).arg(config_pair.first);
  660. answer = isc::config::createAnswer(1, "undefined configuration"
  661. " processing error");
  662. // An error occured, so make sure that we restore original data.
  663. rollback = true;
  664. }
  665. // So far so good, there was no parsing error so let's commit the
  666. // configuration. This will add created subnets and option values into
  667. // the server's configuration.
  668. // This operation should be exception safe but let's make sure.
  669. if (!rollback) {
  670. try {
  671. if (subnet_parser) {
  672. subnet_parser->commit();
  673. }
  674. // No need to commit interface names as this is handled by the
  675. // CfgMgr::commit() function.
  676. // This occurs last as if it succeeds, there is no easy way to
  677. // revert it. As a result, the failure to commit a subsequent
  678. // change causes problems when trying to roll back.
  679. if (hooks_parser) {
  680. hooks_parser->commit();
  681. }
  682. }
  683. catch (const isc::Exception& ex) {
  684. LOG_ERROR(dhcp6_logger, DHCP6_PARSER_COMMIT_FAIL).arg(ex.what());
  685. answer = isc::config::createAnswer(2, ex.what());
  686. // An error occured, so make sure to restore the original data.
  687. rollback = true;
  688. } catch (...) {
  689. // for things like bad_cast in boost::lexical_cast
  690. LOG_ERROR(dhcp6_logger, DHCP6_PARSER_COMMIT_EXCEPTION);
  691. answer = isc::config::createAnswer(2, "undefined configuration"
  692. " parsing error");
  693. // An error occured, so make sure to restore the original data.
  694. rollback = true;
  695. }
  696. }
  697. // Rollback changes as the configuration parsing failed.
  698. if (rollback) {
  699. globalContext().reset(new ParserContext(original_context));
  700. return (answer);
  701. }
  702. LOG_INFO(dhcp6_logger, DHCP6_CONFIG_COMPLETE)
  703. .arg(CfgMgr::instance().getCurrentCfg()->
  704. getConfigSummary(SrvConfig::CFGSEL_ALL6));
  705. // Everything was fine. Configuration is successful.
  706. answer = isc::config::createAnswer(0, "Configuration successful.");
  707. return (answer);
  708. }
  709. ParserContextPtr& globalContext() {
  710. static ParserContextPtr global_context_ptr(new ParserContext(Option::V6));
  711. return (global_context_ptr);
  712. }
  713. }; // end of isc::dhcp namespace
  714. }; // end of isc namespace