Kea 3.0.0
bin/agent/simple_parser.cc
Go to the documentation of this file.
1// Copyright (C) 2017-2025 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/.
6
7#include <config.h>
8
11#include <cc/data.h>
14#include <hooks/hooks_manager.h>
15#include <hooks/hooks_parser.h>
17
18using namespace isc::data;
19using namespace isc::asiolink;
20using namespace isc::config;
21
22namespace isc {
23namespace agent {
38
43 { "http-host", Element::string, "127.0.0.1" },
44 { "http-port", Element::integer, "8000" },
45 { "trust-anchor", Element::string, "" },
46 { "cert-file", Element::string, "" },
47 { "key-file", Element::string, "" },
48 { "cert-required", Element::boolean, "true" }
49};
50
53 { "type", Element::string, "basic" },
54 { "realm", Element::string, "kea-control-agent" },
55 { "directory", Element::string, "" }
56};
57
61 { "socket-type", Element::string, "unix" }
62};
63
65
69
71 size_t cnt = 0;
72
73 // Set global defaults first.
74 cnt = setDefaults(global, AGENT_DEFAULTS);
75
76 // After set the defaults for authentication if it exists.
77 ConstElementPtr authentication = global->get("authentication");
78 if (authentication) {
79 ElementPtr auth = boost::const_pointer_cast<Element>(authentication);
80 if (auth) {
82 }
83 }
84
85 // Now set the defaults for control-sockets, if any.
86 ConstElementPtr sockets = global->get("control-sockets");
87 if (sockets) {
88 ElementPtr d2 = boost::const_pointer_cast<Element>(sockets->get("d2"));
89 if (d2) {
91 }
92
93 ElementPtr d4 = boost::const_pointer_cast<Element>(sockets->get("dhcp4"));
94 if (d4) {
96 }
97
98 ElementPtr d6 = boost::const_pointer_cast<Element>(sockets->get("dhcp6"));
99 if (d6) {
101 }
102 }
103
104 return (cnt);
105}
106
107void
109 ConstElementPtr ca = config->get("trust-anchor");
110 ConstElementPtr cert = config->get("cert-file");
111 ConstElementPtr key = config->get("key-file");
112 bool have_ca = (ca && !ca->stringValue().empty());
113 bool have_cert = (cert && !cert->stringValue().empty());
114 bool have_key = (key && !key->stringValue().empty());
115 if (!have_ca && !have_cert && !have_key) {
116 // No TLS parameter so TLS is not used.
117 return;
118 }
119 // TLS is used: all 3 parameters are required.
120 if (!have_ca) {
121 isc_throw(ConfigError, "trust-anchor parameter is missing or empty:"
122 " all or none of TLS parameters must be set");
123 }
124 if (!have_cert) {
125 isc_throw(ConfigError, "cert-file parameter is missing or empty:"
126 " all or none of TLS parameters must be set");
127 }
128 if (!have_key) {
129 isc_throw(ConfigError, "key-file parameter is missing or empty:"
130 " all or none of TLS parameters must be set");
131 }
132}
133
134void
137 bool check_only) {
138
139 // Let's get the HTTP parameters first.
140 ctx->setHttpHost(SimpleParser::getString(config, "http-host"));
141 ctx->setHttpPort(SimpleParser::getIntType<uint16_t>(config, "http-port"));
142
143 // TLS parameter are second.
144 ctx->setTrustAnchor(SimpleParser::getString(config, "trust-anchor"));
145 ctx->setCertFile(SimpleParser::getString(config, "cert-file"));
146 ctx->setKeyFile(SimpleParser::getString(config, "key-file"));
147 ctx->setCertRequired(SimpleParser::getBoolean(config, "cert-required"));
148
149 // Control sockets are third.
150 ConstElementPtr ctrl_sockets = config->get("control-sockets");
151 if (ctrl_sockets) {
152 auto const& sockets_map = ctrl_sockets->mapValue();
153 for (auto const& cs : sockets_map) {
154 // Add a validated socket name so we can suppress it in
155 // toElement() but don't have to revalidate it every time we
156 // want to use it.
157 auto mutable_socket_info = boost::const_pointer_cast<Element>(cs.second);
158 std::string socket_name = mutable_socket_info->get("socket-name")->stringValue();
159 auto validated_name = UnixCommandConfig::validatePath(socket_name);
160 mutable_socket_info->set("validated-socket-name", Element::create(validated_name));
161 ctx->setControlSocketInfo(mutable_socket_info, cs.first);
162 }
163 }
164
165 // Basic HTTP authentications are fourth.
166 ConstElementPtr auth_config = config->get("authentication");
167 if (auth_config) {
168 using namespace isc::http;
170 auth->parse(auth_config);
171 ctx->setAuthConfig(auth);
172 }
173
174 // HTTP headers are fifth.
175 ConstElementPtr headers_config = config->get("http-headers");
176 if (headers_config) {
177 using namespace isc::http;
178 ctx->setHttpHeaders(parseCfgHttpHeaders(headers_config));
179 }
180
181 // User context can be done at anytime.
182 ConstElementPtr user_context = config->get("user-context");
183 if (user_context) {
184 ctx->setContext(user_context);
185 }
186
187 // Finally, let's get the hook libs!
188 using namespace isc::hooks;
189 HooksConfig& libraries = ctx->getHooksConfig();
190 ConstElementPtr hooks = config->get("hooks-libraries");
191 if (hooks) {
192 HooksLibrariesParser hooks_parser;
193 hooks_parser.parse(libraries, hooks);
194 libraries.verifyLibraries(hooks->getPosition(), false);
195 }
196
197 if (!check_only) {
198 // This occurs last as if it succeeds, there is no easy way
199 // revert it. As a result, the failure to commit a subsequent
200 // change causes problems when trying to roll back.
202 static_cast<void>(HooksManager::unloadLibraries());
204 libraries.loadLibraries(false);
205 }
206}
207
208}
209}
static ElementPtr create(const Position &pos=ZERO_POSITION())
Definition data.cc:249
@ integer
Definition data.h:140
@ boolean
Definition data.h:142
@ string
Definition data.h:144
An exception that is thrown if an error occurs while configuring any server.
void checkTlsSetup(const isc::data::ConstElementPtr &config)
Check TLS setup consistency i.e.
static const isc::data::SimpleDefaults AUTH_DEFAULTS
This table defines default values for authentication.
static const isc::data::SimpleDefaults SOCKET_DEFAULTS
This table defines default values for control sockets.
static const isc::data::SimpleDefaults AGENT_DEFAULTS
This table defines default values for global options.
void parse(const CtrlAgentCfgContextPtr &ctx, const isc::data::ConstElementPtr &config, bool check_only)
Parses the control agent configuration.
static size_t setAllDefaults(const isc::data::ElementPtr &global)
Sets all defaults for Control Agent configuration.
static std::string validatePath(const std::string socket_path)
Validates a path against the supported path for unix control sockets.
static std::string getString(isc::data::ConstElementPtr scope, const std::string &name)
Returns a string parameter from a scope.
int_type getIntType(isc::data::ConstElementPtr scope, const std::string &name)
Returns an integer value with range checking from a scope.
static bool getBoolean(isc::data::ConstElementPtr scope, const std::string &name)
Returns a boolean parameter from a scope.
static size_t setDefaults(isc::data::ElementPtr scope, const SimpleDefaults &default_values)
Sets the default values.
Wrapper class that holds hooks libraries configuration.
void verifyLibraries(const isc::data::Element::Position &position, bool multi_threading_enabled) const
Verifies that libraries stored in libraries_ are valid.
void loadLibraries(bool multi_threading_enabled) const
Commits hooks libraries configuration.
Parser for hooks library list.
void parse(HooksConfig &libraries, isc::data::ConstElementPtr value)
Parses parameters value.
static bool unloadLibraries()
Unload libraries.
static void prepareUnloadLibraries()
Prepare the unloading of libraries.
Basic HTTP authentication configuration.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
boost::shared_ptr< CtrlAgentCfgContext > CtrlAgentCfgContextPtr
Pointer to a configuration context.
Definition ca_cfg_mgr.h:24
boost::shared_ptr< const Element > ConstElementPtr
Definition data.h:29
std::vector< SimpleDefault > SimpleDefaults
This specifies all default values in a given scope (e.g. a subnet).
boost::shared_ptr< Element > ElementPtr
Definition data.h:28
boost::shared_ptr< BasicHttpAuthConfig > BasicHttpAuthConfigPtr
Type of shared pointers to basic HTTP authentication configuration.
CfgHttpHeaders parseCfgHttpHeaders(const ConstElementPtr &config)
Parse config HTTP headers.
Defines the logger used by the top-level component of kea-lfc.