{
"comment": "control socket for DHCPv4 server",
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
}
},
{
"comment": "socket to DHCPv4 server",
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Location of the DHCPv6 command channel socket.
"dhcp6":
{
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Location of the D2 command channel socket.
"d2":
{
"socket-type": "unix",
- "socket-name": "/tmp/kea-ddns-ctrl-socket",
+ "socket-name": "kea-ddns-ctrl-socket",
"user-context": { "in-use": false }
}
},
// Location of the UNIX domain socket file the DHCP-DDNS server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea-ddns-ctrl-socket",
+ "socket-name": "kea-ddns-ctrl-socket",
// Control socket type used by the Kea DHCP-DDNS server.
// The 'unix' socket is currently the only supported type.
// Location of the UNIX domain socket file the DHCP-DDNS server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea-ddns-ctrl-socket",
+ "socket-name": "kea-ddns-ctrl-socket",
// Control socket type used by the Kea DHCP-DDNS server.
// The 'unix' socket is currently the only supported type.
{
"comment": "Control channel",
"socket-type": "unix",
- "socket-name": "/tmp/kea-ddns-ctrl-socket"
+ "socket-name": "kea-ddns-ctrl-socket"
},
"forward-ddns":
"control-socket":
{
"socket-type": "unix",
- "socket-name": "/tmp/kea-ddns-ctrl-socket"
+ "socket-name": "kea-ddns-ctrl-socket"
},
// ----------------- Hooks Libraries -----------------
// "control-socket":
// {
// "socket-type": "unix",
-// "socket-name": "/tmp/kea-ddns-ctrl-socket"
+// "socket-name": "kea-ddns-ctrl-socket"
// },
// ----------------- Forward DDNS ------------------
// Guide for list of supported commands.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Addresses will be assigned with a lifetime of 4000 seconds.
// Location of the UNIX domain socket file the DHCPv4 server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea4-ctrl-socket",
+ "socket-name": "kea4-ctrl-socket",
// Control socket type used by the Kea DHCPv4 server. The 'unix'
// socket is currently the only supported type.
// Location of the UNIX domain socket file the DHCPv4 server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea4-ctrl-socket",
+ "socket-name": "kea4-ctrl-socket",
// Control socket type used by the Kea DHCPv4 server. The 'unix'
// socket is currently the only supported type.
// In control socket (more for the agent)
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket",
+ "socket-name": "kea4-ctrl-socket",
"user-context": { "comment": "Indirect comment" }
},
// details.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Hooks libraries that enable configuration backend are loaded.
"name": "kea-dhcp4",
"output-options": [
{
- "output": "/tmp/kea-dhcp4.log"
+ "output": "kea-dhcp4.log"
}
],
"severity": "DEBUG",
// The Control Agent is used only to handle user commands.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Multi-threading parameters.
// The Control Agent is used only to handle user commands.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Multi-threading parameters.
// Guide for list of supported commands.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Addresses will be assigned with preferred and valid lifetimes
// Location of the UNIX domain socket file the DHCPv6 server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea6-ctrl-socket",
+ "socket-name": "kea6-ctrl-socket",
// Control socket type used by the Kea DHCPv6 server. The 'unix'
// socket is currently the only supported type.
// Location of the UNIX domain socket file the DHCPv6 server uses
// to receive control commands from the Kea Control Agent or the
// local server administrator.
- "socket-name": "/tmp/kea6-ctrl-socket",
+ "socket-name": "kea6-ctrl-socket",
// Control socket type used by the Kea DHCPv6 server. The 'unix'
// socket is currently the only supported type.
// In control socket (more for the agent)
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket",
+ "socket-name": "kea6-ctrl-socket",
"user-context": { "comment": "Indirect comment" }
},
// details.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Hooks libraries that enable configuration backend are loaded.
"name": "kea-dhcp6",
"output-options": [
{
- "output": "/tmp/kea-dhcp6.log"
+ "output": "kea-dhcp6.log"
}
],
"severity": "DEBUG",
// API between the HA peers.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Use Memfile lease database backend to store leases in a CSV file.
// API between the HA peers.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Use Memfile lease database backend to store leases in a CSV file.
{
"comment": "using unix/local socket",
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
}
}
},
"control-socket":
{
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Comment is optional. You can put some notes here.
"control-socket":
{
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Comment is optional. You can put some notes here.
:ref:`d2-ctrl-channel` to learn how the socket configuration is
specified for the DHCPv4, DHCPv6, and D2 services.
+.. note::
+
+ As of Kea 2.6.3, control sockets may only reside in the directory
+ determined during compilation as ``"[kea-install-dir]/var/run/kea"``. This
+ path may be overridden at startup by setting the environment variable
+ ``KEA_CONTROL_SOCKET_DIR`` to the desired path. If a path other than
+ this value is used in ``socket-name``, Kea will emit an error and refuse to
+ start or, if already running, log an unrecoverable error. For ease of use in
+ simply omit the path component from ``socket-name``.
+
User contexts can store arbitrary data as long as they are in valid JSON
syntax and their top-level element is a map (i.e. the data must be
enclosed in curly brackets). Some hook libraries may expect specific
different operating systems, between 91 and 107 characters. Typical
values are 107 on Linux and 103 on FreeBSD.
+.. note::
+
+ As of Kea 2.6.3, control sockets may only reside in the directory
+ determined during compilation as ``"[kea-install-dir]/var/run/kea"``. This
+ path may be overridden at startup by setting the environment variable
+ ``KEA_CONTROL_SOCKET_DIR`` to the desired path. If a path other than
+ this value is used in ``socket-name``, Kea will emit an error and refuse to
+ start or, if already running, log an unrecoverable error. For ease of use in
+ simply omit the path component from ``socket-name``.
+
Communication over the control channel is conducted using JSON structures.
See the `Control Channel section in the Kea Developer's
Guide <https://reports.kea.isc.org/dev_guide/d2/d96/ctrlSocket.html>`__
different operating systems, between 91 and 107 characters. Typical
values are 107 on Linux and 103 on FreeBSD.
+.. note::
+
+ As of Kea 2.6.3, control sockets may only reside in the directory
+ determined during compilation as ``"[kea-install-dir]/var/run/kea"``. This
+ path may be overridden at startup by setting the environment variable
+ ``KEA_CONTROL_SOCKET_DIR`` to the desired path. If a path other than
+ this value is used in ``socket-name``, Kea will emit an error and refuse to
+ start or, if already running, log an unrecoverable error. For ease of use in
+ simply omit the path component from ``socket-name``.
+
Communication over the control channel is conducted using JSON
structures. See the
`Control Channel section in the Kea Developer's Guide
different operating systems, between 91 and 107 characters. Typical
values are 107 on Linux and 103 on FreeBSD.
+.. note::
+
+ As of Kea 2.6.3, control sockets may only reside in the directory
+ determined during compilation as ``"[kea-install-dir]/var/run/kea"``. This
+ path may be overridden at startup by setting the environment variable
+ ``KEA_CONTROL_SOCKET_DIR`` to the desired path. If a path other than
+ this value is used in ``socket-name``, Kea will emit an error and refuse to
+ start or, if already running, log an unrecoverable error. For ease of use in
+ simply omit the path component from ``socket-name``.
+
Communication over the control channel is conducted using JSON
structures. See the
`Control Channel section in the Kea Developer's Guide
As of Kea 2.6.3, hook libraries may only be loaded from the default installation
directory determined during compilation and shown in the config report as
-"Hooks directory". This value may be overridden at startup by setting the
+"Hooks directory". This value may be overridden at startup by setting the
environment variable ``KEA_HOOKS_PATH`` to the desired path. If a path other
than this value is used in a ``library`` element Kea will emit an error and refuse
to load the library. For ease of use ``library`` elements may simply omit path
// Set control-sockets
ElementPtr control_sockets = Element::createMap();
for (auto const& si : ctrl_sockets_) {
- ConstElementPtr socket = UserContext::toElement(si.second);
- control_sockets->set(si.first, socket);
+ // Remove validated_path.
+ auto mutable_socket_info = boost::const_pointer_cast<Element>(
+ UserContext::toElement(si.second));
+ mutable_socket_info->remove("validated-socket-name");
+ control_sockets->set(si.first, mutable_socket_info);
}
+
ca->set("control-sockets", control_sockets);
// Set Control-agent
ElementPtr result = Element::createMap();
" for the server type " << service);
}
- // If the configuration does its job properly the socket-name must be
- // specified and must be a string value.
- std::string socket_name = socket_info->get("socket-name")->stringValue();
+ // If the configuration does its job properly the validated-socket-name
+ // should be present.
+ if (!socket_info->get("validated-socket-name")) {
+ isc_throw(Unexpected, "validated-socket-name missing from "
+ << " socket_info: " << socket_info->str()
+ << " for the server type " << service);
+ }
+
+ auto socket_name = socket_info->get("validated-socket-name")->stringValue();
// Forward command and receive reply.
IOServicePtr io_service(new IOService());;
-// Copyright (C) 2017-2024 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2017-2025 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
#include <asiolink/io_service_mgr.h>
#include <cc/data.h>
#include <cc/dhcp_config_error.h>
+#include <config/unix_command_config.h>
#include <hooks/hooks_manager.h>
#include <hooks/hooks_parser.h>
#include <http/basic_auth_config.h>
using namespace isc::data;
using namespace isc::asiolink;
+using namespace isc::config;
namespace isc {
namespace agent {
if (ctrl_sockets) {
auto const& sockets_map = ctrl_sockets->mapValue();
for (auto const& cs : sockets_map) {
- ctx->setControlSocketInfo(cs.second, cs.first);
+ // Add a validated socket name so we can suppress it in
+ // toElement() but don't have to revalidate it every time we
+ // want to use it.
+ auto mutable_socket_info = boost::const_pointer_cast<Element>(cs.second);
+ std::string socket_name = mutable_socket_info->get("socket-name")->stringValue();
+ auto validated_name = UnixCommandConfig::validatePath(socket_name);
+ mutable_socket_info->set("validated-socket-name", Element::create(validated_name));
+ ctx->setControlSocketInfo(mutable_socket_info, cs.first);
}
}
#include <config.h>
#include <agent/ca_cfg_mgr.h>
#include <agent/parser_context.h>
+#include <config/unix_command_config.h>
#include <exceptions/exceptions.h>
#include <process/testutils/d_test_stubs.h>
#include <process/d_cfg_mgr.h>
#include <http/basic_auth_config.h>
#include <hooks/hooks_parser.h>
+#include <util/filesystem.h>
#include <agent/tests/test_callout_libraries.h>
#include <agent/tests/test_data_files_config.h>
#include <boost/pointer_cast.hpp>
using namespace isc::hooks;
using namespace isc::http;
using namespace isc::process;
+using namespace isc::config;
+using namespace isc::util;
namespace {
auth->setRealm("foobar");
auth->setDirectory("/tmp");
- auth->add("", "/tmp/foo", "", "/tmp/bar");
- auth->add("", "/tmp/test", "", "/tmp/pwd");
+ auth->add("", "foo", "", "bar");
+ auth->add("", "test", "", "pwd");
const HttpAuthConfigPtr& stored_auth = ctx.getAuthConfig();
ASSERT_TRUE(stored_auth);
" \"http-port\": 8001,\n"
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" }\n"
" }\n"
"}",
" \"http-port\": 8001,\n"
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" },\n"
" \"dhcp6\": {\n"
- " \"socket-name\": \"/tmp/socket-v6\"\n"
+ " \"socket-name\": \"socket-v6\"\n"
" },\n"
" \"d2\": {\n"
- " \"socket-name\": \"/tmp/socket-d2\"\n"
+ " \"socket-name\": \"socket-d2\"\n"
" }\n"
" }\n"
"}",
" \"http-port\": 8001,\n"
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" }\n"
" },\n"
" \"hooks-libraries\": ["
" \"http-port\": 8001,\n"
" \"control-sockets\": {\n"
" \"d2\": {\n"
- " \"socket-name\": \"/tmp/socket-d2\"\n"
+ " \"socket-name\": \"socket-d2\"\n"
" }\n"
" }\n"
"}",
" \"http-port\": 8001,\n"
" \"control-sockets\": {\n"
" \"dhcp6\": {\n"
- " \"socket-name\": \"/tmp/socket-v6\"\n"
+ " \"socket-name\": \"socket-v6\"\n"
" }\n"
" }\n"
"}",
" },\n"
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" }\n"
" }\n"
"}",
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
" \"comment\": \"dhcp4 socket\",\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" },\n"
" \"dhcp6\": {\n"
- " \"socket-name\": \"/tmp/socket-v6\",\n"
+ " \"socket-name\": \"socket-v6\",\n"
" \"user-context\": { \"version\": 1 }\n"
" }\n"
" }\n"
" },\n"
" \"control-sockets\": {\n"
" \"dhcp4\": {\n"
- " \"socket-name\": \"/tmp/socket-v4\"\n"
+ " \"socket-name\": \"socket-v4\"\n"
" }\n"
" }\n"
"}"
/// @brief Constructor.
AgentParserTest() {
resetHooksPath();
+ setSocketTestPath();
}
/// @brief Destructor.
virtual ~AgentParserTest() {
resetHooksPath();
+ resetSocketPath();
}
/// @brief Sets the Hooks path from which hooks can be loaded.
HooksLibrariesParser::getHooksPath(true);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ auto path = UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Tries to load input text as a configuration
///
/// @param config text containing input configuration
return (txt);
}
+ /// @brief Make expected contents of socket info with socket path added.
+ ///
+ /// @param name name of the socket
+ /// @return expected string
+ std::string makeSocketStr(const std::string& name) {
+ std::ostringstream os;
+ os << "{ \"socket-name\": \""
+ << name << "\", \"socket-type\": \"unix\","
+ << " \"validated-socket-name\": \""
+ << UnixCommandConfig::getSocketPath() << "/" << name
+ << "\" }";
+ return (os.str());
+ }
+
/// Configuration Manager (used in tests)
NakedAgentCfgMgr cfg_mgr_;
};
ASSERT_TRUE(ctx);
ConstElementPtr socket = ctx->getControlSocketInfo("dhcp4");
ASSERT_TRUE(socket);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-v4\", \"socket-type\": \"unix\" }",
- socket->str());
+ EXPECT_EQ(makeSocketStr("socket-v4"), socket->str());
EXPECT_FALSE(ctx->getControlSocketInfo("dhcp6"));
EXPECT_FALSE(ctx->getControlSocketInfo("d2"));
}
ASSERT_TRUE(ctx);
ConstElementPtr socket = ctx->getControlSocketInfo("d2");
ASSERT_TRUE(socket);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-d2\", \"socket-type\": \"unix\" }",
- socket->str());
-
+ EXPECT_EQ(makeSocketStr("socket-d2"), socket->str());
EXPECT_FALSE(ctx->getControlSocketInfo("dhcp4"));
EXPECT_FALSE(ctx->getControlSocketInfo("dhcp6"));
}
ASSERT_TRUE(ctx);
ConstElementPtr socket = ctx->getControlSocketInfo("dhcp6");
ASSERT_TRUE(socket);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-v6\", \"socket-type\": \"unix\" }",
- socket->str());
+ EXPECT_EQ(makeSocketStr("socket-v6"), socket->str());
EXPECT_FALSE(ctx->getControlSocketInfo("dhcp4"));
EXPECT_FALSE(ctx->getControlSocketInfo("d2"));
}
ConstElementPtr socket4 = ctx->getControlSocketInfo("dhcp4");
ConstElementPtr socket6 = ctx->getControlSocketInfo("dhcp6");
ASSERT_TRUE(socket2);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-d2\", \"socket-type\": \"unix\" }",
- socket2->str());
+ EXPECT_EQ(makeSocketStr("socket-d2"), socket2->str());
ASSERT_TRUE(socket4);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-v4\", \"socket-type\": \"unix\" }",
- socket4->str());
+ EXPECT_EQ(makeSocketStr("socket-v4"), socket4->str());
ASSERT_TRUE(socket6);
- EXPECT_EQ("{ \"socket-name\": \"/tmp/socket-v6\", \"socket-type\": \"unix\" }",
- socket6->str());
+ EXPECT_EQ(makeSocketStr("socket-v6"), socket6->str());
}
// This test checks that the config file with hook library specified can be
#include <asiolink/testutils/test_server_unix_socket.h>
#include <cc/command_interpreter.h>
#include <cc/data.h>
+#include <config/unix_command_config.h>
#include <process/testutils/d_test_stubs.h>
+#include <util/filesystem.h>
#include <boost/pointer_cast.hpp>
#include <gtest/gtest.h>
#include <testutils/sandbox.h>
using namespace isc::asiolink;
using namespace isc::data;
using namespace isc::process;
+using namespace isc::config;
+using namespace isc::util;
namespace {
: DControllerTest(CtrlAgentController::instance),
mgr_(CtrlAgentCommandMgr::instance()) {
mgr_.deregisterAll();
+ setSocketTestPath();
removeUnixSocketFile();
initProcess();
}
virtual ~CtrlAgentCommandMgrTest() {
mgr_.deregisterAll();
removeUnixSocketFile();
+ resetSocketPath();
}
/// @brief Verifies received answer
}
/// @brief Returns socket file path.
- ///
- /// If the KEA_SOCKET_TEST_DIR environment variable is specified, the
- /// socket file is created in the location pointed to by this variable.
- /// Otherwise, it is created in the build directory.
std::string unixSocketFilePath() {
- std::string socket_path;
- const char* env = getenv("KEA_SOCKET_TEST_DIR");
- if (env) {
- socket_path = std::string(env) + "/test-socket";
- } else {
- socket_path = sandbox.join("test-socket");
- }
- return (socket_path);
+ return (UnixCommandConfig::getSocketPath() + "/test-socket");
+ }
+
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ auto path = UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
}
/// @brief Removes unix socket descriptor.
ASSERT_TRUE(ctx);
ElementPtr control_socket = Element::createMap();
- control_socket->set("socket-name",
+ control_socket->set("validated-socket-name",
Element::create(unixSocketFilePath()));
ctx->setControlSocketInfo(control_socket, service);
}
#include <agent/ca_command_mgr.h>
#include <cc/data.h>
#include <cc/command_interpreter.h>
+#include <config/unix_command_config.h>
#include <process/testutils/d_test_stubs.h>
+#include <util/filesystem.h>
#include <testutils/gtest_utils.h>
#include <boost/pointer_cast.hpp>
using namespace isc::data;
using namespace isc::http;
using namespace isc::process;
+using namespace isc::config;
+using namespace isc::util;
using namespace boost::posix_time;
using namespace std;
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/first/dhcp4/socket\""
+ " \"socket-name\": \"first_socket4\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/first/dhcp6/socket\""
+ " \"socket-name\": \"first_socket6\""
" }"
" }"
"}";
/// @brief Constructor.
CtrlAgentControllerTest()
: DControllerTest(CtrlAgentController::instance) {
+ setSocketTestPath();
+ }
+
+ /// @brief Destructor.
+ virtual ~CtrlAgentControllerTest() {
+ resetSocketPath();
}
/// @brief Returns pointer to CtrlAgentProcess instance.
return (p);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ auto path = UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Tests that socket info structure contains 'unix' socket-type
/// value and the expected socket-name.
///
ASSERT_TRUE(sock_info->contains("socket-type"));
EXPECT_EQ("unix", sock_info->get("socket-type")->stringValue());
ASSERT_TRUE(sock_info->contains("socket-name"));
- EXPECT_EQ(exp_socket_name,
- sock_info->get("socket-name")->stringValue());
+ EXPECT_EQ(exp_socket_name, sock_info->get("socket-name")->stringValue());
}
/// @brief Compares the status in the given parse result to a given value.
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp4/socket\""
+ " \"socket-name\": \"second_socket6\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp6/socket\""
+ " \"socket-name\": \"second_socket6\""
" }"
" }"
"}";
EXPECT_EQ(8080, ctx->getHttpPort());
// The forwarding configuration should have been updated too.
- testUnixSocketInfo("dhcp4", "/second/dhcp4/socket");
- testUnixSocketInfo("dhcp6", "/second/dhcp6/socket");
+ testUnixSocketInfo("dhcp4", "second_socket6");
+ testUnixSocketInfo("dhcp6", "second_socket6");
// After the shutdown the HTTP listener no longer exists.
CtrlAgentProcessPtr process = getCtrlAgentProcess();
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp4/socket\""
+ " \"socket-name\": \"second_socket6\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp6/socket\""
+ " \"socket-name\": \"second_socket6\""
" }"
" }"
"}";
EXPECT_EQ(8081, ctx->getHttpPort());
// Same for forwarding.
- testUnixSocketInfo("dhcp4", "/first/dhcp4/socket");
- testUnixSocketInfo("dhcp6", "/first/dhcp6/socket");
+ testUnixSocketInfo("dhcp4", "first_socket4");
+ testUnixSocketInfo("dhcp6", "first_socket6");
// After the shutdown the HTTP listener no longer exists.
CtrlAgentProcessPtr process = getCtrlAgentProcess();
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp4/socket\""
+ " \"socket-name\": \"second_socket6\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/second/dhcp6/socket\""
+ " \"socket-name\": \"second_socket6\""
" }"
" }"
"}";
EXPECT_EQ(8081, ctx->getHttpPort());
// The forwarding configuration should have been updated.
- testUnixSocketInfo("dhcp4", "/second/dhcp4/socket");
- testUnixSocketInfo("dhcp6", "/second/dhcp6/socket");
+ testUnixSocketInfo("dhcp4", "second_socket6");
+ testUnixSocketInfo("dhcp6", "second_socket6");
CtrlAgentProcessPtr process = getCtrlAgentProcess();
ASSERT_TRUE(process);
#include <cc/data.h>
#include <cc/command_interpreter.h>
+#include <config/unix_command_config.h>
#include <testutils/user_context_utils.h>
#include <process/testutils/d_test_stubs.h>
#include <agent/ca_cfg_mgr.h>
#include <agent/parser_context.h>
#include <hooks/hooks_parser.h>
+#include <util/filesystem.h>
#include <boost/scoped_ptr.hpp>
#include <gtest/gtest.h>
using namespace isc::process;
using namespace isc::hooks;
using namespace isc::test;
+using namespace isc::config;
+using namespace isc::util;
namespace {
srv_.reset(new NakedAgentCfgMgr());
// Create fresh context.
resetConfiguration();
+ setSocketTestPath();
}
~CtrlAgentGetCfgTest() {
resetConfiguration();
resetHooksPath();
+ resetSocketPath();
}
/// @brief Sets the Hooks path from which hooks can be loaded.
HooksLibrariesParser::getHooksPath(true);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ auto path = UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Parse and Execute configuration
///
/// Parses a configuration and executes a configuration of the server.
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea4-ctrl-socket\""
+ " \"socket-name\": \"kea4-ctrl-socket\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea6-ctrl-socket\""
+ " \"socket-name\": \"kea6-ctrl-socket\""
" },"
" \"d2\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea-ddns-ctrl-socket\""
+ " \"socket-name\": \"kea-ddns-ctrl-socket\""
" }"
" },"
" \"hooks-libraries\": ["
" \"control-sockets\": {"
" \"dhcp4\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea4-ctrl-socket\""
+ " \"socket-name\": \"kea4-ctrl-socket\""
" },"
" \"dhcp6\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea6-ctrl-socket\""
+ " \"socket-name\": \"kea6-ctrl-socket\""
" },"
" \"d2\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea-ddns-ctrl-socket\""
+ " \"socket-name\": \"kea-ddns-ctrl-socket\""
" }"
" },"
" \"hooks-libraries\": ["
"Control-agent": {
"control-sockets": {
"d2": {
- "socket-name": "/tmp/kea-dhcp-ddns-ctrl.sock",
+ "socket-name": "kea-dhcp-ddns-ctrl.sock",
"socket-type": "unix",
},
"dhcp4": {
- "socket-name": "/tmp/kea-dhcp4-ctrl.sock",
+ "socket-name": "kea-dhcp4-ctrl.sock",
"socket-type": "unix",
},
"dhcp6": {
- "socket-name": "/tmp/kea-dhcp6-ctrl.sock",
+ "socket-name": "kea-dhcp6-ctrl.sock",
"socket-type": "unix",
},
},
},
"control-sockets": {
"d2": {
- "socket-name": "/tmp/kea-ddns-ctrl-socket",
+ "socket-name": "kea-ddns-ctrl-socket",
"socket-type": "unix",
"user-context": {
"in-use": false
}
},
"dhcp4": {
- "socket-name": "/tmp/kea4-ctrl-socket",
+ "socket-name": "kea4-ctrl-socket",
"socket-type": "unix",
"user-context": {
"comment": "socket to DHCPv4 server"
}
},
"dhcp6": {
- "socket-name": "/tmp/kea6-ctrl-socket",
+ "socket-name": "kea6-ctrl-socket",
"socket-type": "unix"
}
},
#include <config.h>
+#include <config/unix_command_config.h>
#include <d2/parser_context.h>
#include <d2/tests/parser_unittest.h>
#include <d2/tests/test_callout_libraries.h>
#include <process/testutils/d_test_stubs.h>
#include <test_data_files_config.h>
#include <util/encode/encode.h>
+#include <util/filesystem.h>
#include <boost/scoped_ptr.hpp>
#include <gtest/gtest.h>
using namespace isc::d2;
using namespace isc::hooks;
using namespace isc::process;
+using namespace isc::config;
+using namespace isc::util;
namespace {
/// @brief Constructor
D2CfgMgrTest():cfg_mgr_(new D2CfgMgr()), d2_params_() {
resetHooksPath();
+ resetSocketPath();
}
/// @brief Destructor
~D2CfgMgrTest() {
resetHooksPath();
+ resetSocketPath();
}
/// @brief Sets the Hooks path from which hooks can be loaded.
HooksLibrariesParser::getHooksPath(true);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Configuration manager instance.
D2CfgMgrPtr cfg_mgr_;
/// event.
TEST_F(D2CfgMgrTest, fullConfig) {
setHooksTestPath();
+ setSocketTestPath();
// Create a configuration with all of application level parameters, plus
// both the forward and reverse ddns managers. Both managers have two
/// @brief Tests comments.
TEST_F(D2CfgMgrTest, comments) {
+ setSocketTestPath();
std::string config = "{ "
"\"comment\": \"D2 config\" , "
"\"ip-address\" : \"192.168.1.33\" , "
#include <asiolink/io_service.h>
#include <cc/command_interpreter.h>
#include <config/command_mgr.h>
+#include <config/unix_command_config.h>
#include <config/timeouts.h>
#include <testutils/io_utils.h>
#include <testutils/unix_control_client.h>
#include <d2/d2_controller.h>
#include <d2/d2_process.h>
#include <d2/parser_context.h>
+#include <util/filesystem.h>
#include <gtest/gtest.h>
#include <testutils/sandbox.h>
#include <boost/pointer_cast.hpp>
using namespace isc::data;
using namespace isc::dhcp::test;
using namespace isc::process;
+using namespace isc::util;
using namespace boost::asio;
namespace ph = std::placeholders;
/// Sets socket path to its default value.
CtrlChannelD2Test()
: server_(NakedD2Controller::instance()) {
- const char* env = getenv("KEA_SOCKET_TEST_DIR");
- if (env) {
- socket_path_ = string(env) + "/d2.sock";
- } else {
- socket_path_ = sandbox.join("d2.sock");
- }
+ setSocketTestPath();
::remove(socket_path_.c_str());
}
// Reset command manager.
CommandMgr::instance().deregisterAll();
CommandMgr::instance().setConnectionTimeout(TIMEOUT_DHCP_SERVER_RECEIVE_COMMAND);
+ resetSocketPath();
}
/// @brief Returns pointer to the server's IO service.
return (server_ ? d2Controller()->getIOService() : IOServicePtr());
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ socket_path_ = path + "/d2.sock";
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Runs parser in DHCPDDNS mode
///
/// @param config input configuration
#include <cc/command_interpreter.h>
#include <cc/data.h>
+#include <config/unix_command_config.h>
#include <d2/parser_context.h>
#include <d2srv/d2_cfg_mgr.h>
#include <d2srv/d2_config.h>
#include <hooks/hooks_parser.h>
#include <process/testutils/d_test_stubs.h>
#include <testutils/user_context_utils.h>
+#include <util/filesystem.h>
#include <gtest/gtest.h>
#include <iostream>
using namespace isc::process;
using namespace isc::test;
using namespace isc::hooks;
+using namespace isc::util;
namespace {
D2GetConfigTest()
: rcode_(-1) {
resetHooksPath();
+ resetSocketPath();
srv_.reset(new D2CfgMgr());
// Enforce not verbose mode.
Daemon::setVerbose(false);
static_cast<void>(remove(test_file_name.c_str()));
resetConfiguration();
resetHooksPath();
+ resetSocketPath();
}
/// @brief Sets the Hooks path from which hooks can be loaded.
HooksLibrariesParser::getHooksPath(true);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+
/// @brief Parse and Execute configuration
///
/// Parses a configuration and executes a configuration of the server.
/// Test a configuration
TEST_F(D2GetConfigTest, sample1) {
setHooksTestPath();
+ setSocketTestPath();
// get the sample1 configuration
std::string sample1_file = string(CFG_EXAMPLES) + "/" + "sample1.json";
{
"DhcpDdns": {
"control-socket": {
- "socket-name": "/tmp/kea-ddns-ctrl-socket",
+ "socket-name": "kea-ddns-ctrl-socket",
"socket-type": "unix"
},
"dns-server-timeout": 1000,
#include <testutils/test_to_element.h>
#include <util/chrono_time_utils.h>
#include <util/doubles.h>
+#include <util/filesystem.h>
#include <boost/scoped_ptr.hpp>
using namespace isc::dhcp::test;
using namespace isc::hooks;
using namespace isc::test;
+using namespace isc::util;
using namespace std;
namespace {
" ],"
" \"control-socket\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea4-ctrl-socket\","
+ " \"socket-name\": \"kea4-ctrl-socket\","
" \"user-context\": { \"comment\": \"Indirect comment\" }"
" },"
" \"shared-networks\": [ {"
resetConfiguration();
resetHooksPath();
+ Dhcpv4SrvTest::resetSocketPath();
}
~Dhcp4ParserTest() {
static_cast<void>(remove(UNLOAD_MARKER_FILE));
resetHooksPath();
+ Dhcpv4SrvTest::resetSocketPath();
}
/// @brief Sets the Hooks path from which hooks can be loaded.
// This test checks comments. Please keep it last.
TEST_F(Dhcp4ParserTest, comments) {
+ Dhcpv4SrvTest::setSocketTestPath();
string config = PARSER_CONFIGS[6];
extractConfig(config);
ASSERT_TRUE(socket->get("socket-type"));
EXPECT_EQ("\"unix\"", socket->get("socket-type")->str());
ASSERT_TRUE(socket->get("socket-name"));
- EXPECT_EQ("\"/tmp/kea4-ctrl-socket\"", socket->get("socket-name")->str());
+ EXPECT_EQ("\"kea4-ctrl-socket\"", socket->get("socket-name")->str());
// Check control socket comment and user context.
ConstElementPtr ctx_socket = socket->get("user-context");
#include <asiolink/io_service.h>
#include <cc/command_interpreter.h>
#include <config/command_mgr.h>
+#include <config/unix_command_config.h>
#include <config/timeouts.h>
#include <dhcp/dhcp4.h>
#include <dhcp/libdhcp++.h>
/// Sets socket path to its default value.
CtrlChannelDhcpv4SrvTest() : interfaces_("\"*\"") {
resetLogPath();
- const char* env = getenv("KEA_SOCKET_TEST_DIR");
- if (env) {
- socket_path_ = string(env) + "/kea4.sock";
- } else {
- socket_path_ = sandbox.join("kea4.sock");
- }
+ setSocketTestPath();
reset();
IfaceMgr::instance().setTestMode(false);
IfaceMgr::instance().setDetectCallback(std::bind(&IfaceMgr::checkDetectIfaces,
/// @brief Destructor
~CtrlChannelDhcpv4SrvTest() {
resetLogPath();
+ Dhcpv4SrvTest::resetSocketPath();
LeaseMgrFactory::destroy();
StatsMgr::instance().removeAll();
LogConfigParser::getLogPath(true);
}
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ Dhcpv4SrvTest::setSocketTestPath(explicit_path);
+ socket_path_ = UnixCommandConfig::getSocketPath() + "/kea4.sock";
+ }
+
/// @brief Returns pointer to the server's IO service.
///
/// @return Pointer to the server's IO service or null pointer if the server
void
Dhcpv4SrvTest::checkConfigFiles() {
+ setSocketTestPath();
DBInitializer dbi;
IfaceMgrTestConfig test_config(true);
string path = CFG_EXAMPLES;
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <cc/command_interpreter.h>
+#include <config/unix_command_config.h>
#include <dhcp4/json_config_parser.h>
#include <dhcp4/tests/dhcp4_test_utils.h>
#include <dhcp/libdhcp++.h>
using namespace isc::asiolink;
using namespace isc::data;
using namespace isc::util;
+using namespace isc::config;
using namespace boost::posix_time;
namespace isc {
}
Dhcpv4SrvTest::~Dhcpv4SrvTest() {
+ resetSocketPath();
// Make sure that we revert to default value
CfgMgr::instance().clear();
MultiThreadingMgr::instance().apply(false, 0, 0);
}
+void
+Dhcpv4SrvTest::setSocketTestPath(const std::string explicit_path /* = "" */) {
+ UnixCommandConfig::getSocketPath(true, (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+}
+
+void
+Dhcpv4SrvTest::resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+}
+
void Dhcpv4SrvTest::addPrlOption(Pkt4Ptr& pkt) {
OptionUint8ArrayPtr option_prl =
/// Removes existing configuration.
virtual ~Dhcpv4SrvTest();
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ static void setSocketTestPath(const std::string explicit_path = "");
+
+ /// @brief Resets the socket path to the default.
+ static void resetSocketPath();
+
/// @brief Add 'Parameter Request List' option to the packet.
///
/// This function adds PRL option comprising the following option codes:
" }\n"
" ],\n"
" \"control-socket\": {\n"
-" \"socket-name\": \"/tmp/kea4-ctrl-socket\",\n"
+" \"socket-name\": \"kea4-ctrl-socket\",\n"
" \"socket-type\": \"unix\",\n"
" \"user-context\": {\n"
" \"comment\": \"Indirect comment\"\n"
" }\n"
" ],\n"
" \"control-socket\": {\n"
-" \"socket-name\": \"/tmp/kea4-ctrl-socket\",\n"
+" \"socket-name\": \"kea4-ctrl-socket\",\n"
" \"socket-type\": \"unix\",\n"
" \"user-context\": {\n"
" \"comment\": \"Indirect comment\"\n"
srv_.reset(new ControlledDhcpv4Srv(0));
// Create fresh context.
resetConfiguration();
+ Dhcpv4SrvTest::setSocketTestPath();
}
~Dhcp4GetConfigTest() {
resetConfiguration();
+ Dhcpv4SrvTest::resetSocketPath();
};
/// @brief Parse and Execute configuration
" ],"
" \"control-socket\": {"
" \"socket-type\": \"unix\","
- " \"socket-name\": \"/tmp/kea6-ctrl-socket\","
+ " \"socket-name\": \"kea6-ctrl-socket\","
" \"user-context\": { \"comment\": \"Indirect comment\" }"
" },"
" \"shared-networks\": [ {"
// This test checks comments. Please keep it last.
TEST_F(Dhcp6ParserTest, comments) {
+ setSocketTestPath();
string config = PARSER_CONFIGS[9];
extractConfig(config);
ASSERT_TRUE(socket->get("socket-type"));
EXPECT_EQ("\"unix\"", socket->get("socket-type")->str());
ASSERT_TRUE(socket->get("socket-name"));
- EXPECT_EQ("\"/tmp/kea6-ctrl-socket\"", socket->get("socket-name")->str());
+ EXPECT_EQ("\"kea6-ctrl-socket\"", socket->get("socket-name")->str());
// Check control socket comment and user context.
ConstElementPtr ctx_socket = socket->get("user-context");
#include <asiolink/io_address.h>
#include <cc/command_interpreter.h>
#include <config/command_mgr.h>
+#include <config/unix_command_config.h>
#include <config/timeouts.h>
#include <dhcp/libdhcp++.h>
#include <dhcp/testutils/iface_mgr_test_config.h>
///
/// Sets socket path to its default value.
CtrlChannelDhcpv6SrvTest() : interfaces_("\"*\"") {
- const char* env = getenv("KEA_SOCKET_TEST_DIR");
- if (env) {
- socket_path_ = string(env) + "/kea6.sock";
- } else {
- socket_path_ = sandbox.join("/kea6.sock");
- }
reset();
IfaceMgr::instance().setTestMode(false);
IfaceMgr::instance().setDetectCallback(std::bind(&IfaceMgr::checkDetectIfaces,
IfaceMgr::instancePtr().get(), ph::_1));
+ setSocketTestPath();
+ socket_path_ = UnixCommandConfig::getSocketPath() + "/kea6.sock";
}
/// @brief Destructor
void
Dhcpv6SrvTest::checkConfigFiles() {
+ setSocketTestPath();
DBInitializer dbi;
IfaceMgrTestConfig test_config(true);
string path = CFG_EXAMPLES;
#include <config.h>
#include <gtest/gtest.h>
#include <cc/command_interpreter.h>
+#include <config/unix_command_config.h>
#include <dhcp/option6_status_code.h>
#include <dhcp/testutils/pkt_captures.h>
#include <dhcpsrv/cfg_multi_threading.h>
using namespace isc::stats;
using namespace isc::util;
using namespace isc::process;
+using namespace isc::config;
using namespace boost::posix_time;
namespace isc {
original_datadir_ = CfgMgr::instance().getDataDir();
CfgMgr::instance().getDataDir(true, TEST_DATA_BUILDDIR);
resetLogPath();
+ resetSocketPath();
}
BaseServerTest::~BaseServerTest() {
// Revert to unit test logging, in case the test reconfigured it.
isc::log::initLogger();
resetLogPath();
+ resetSocketPath();
}
void
LogConfigParser::getLogPath(true);
}
+void
+BaseServerTest::setSocketTestPath(const std::string explicit_path /* = "" */) {
+ UnixCommandConfig::getSocketPath(true,
+ (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+}
+
+void
+BaseServerTest::resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+}
+
Dhcpv6SrvTest::Dhcpv6SrvTest()
: NakedDhcpv6SrvTest(), srv_(0), multi_threading_(false) {
subnet_ = Subnet6::create(isc::asiolink::IOAddress("2001:db8:1::"),
/// @brief Resets the log path to TEST_DATA_BUILDDIR.
void resetLogPath();
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the socket path.
+ static void setSocketTestPath(const std::string explicit_path = "");
+
+ /// @brief Resets the socket path to the default.
+ static void resetSocketPath();
+
private:
/// @brief Holds the original data directory.
" }\n"
" ],\n"
" \"control-socket\": {\n"
-" \"socket-name\": \"/tmp/kea6-ctrl-socket\",\n"
+" \"socket-name\": \"kea6-ctrl-socket\",\n"
" \"socket-type\": \"unix\",\n"
" \"user-context\": {\n"
" \"comment\": \"Indirect comment\"\n"
" }\n"
" ],\n"
" \"control-socket\": {\n"
-" \"socket-name\": \"/tmp/kea6-ctrl-socket\",\n"
+" \"socket-name\": \"kea6-ctrl-socket\",\n"
" \"socket-type\": \"unix\",\n"
" \"user-context\": {\n"
" \"comment\": \"Indirect comment\"\n"
// Reset configuration for each test.
resetConfiguration();
+ BaseServerTest::setSocketTestPath();
}
~Dhcp6GetConfigTest() {
// Reset configuration database after each test.
resetConfiguration();
+ BaseServerTest::resetSocketPath();
};
/// @brief Parse and Execute configuration
"control-sockets": {
"dhcp4": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
"dhcp6": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
"d2": {
"socket-type": "unix",
- "socket-name": "/tmp/kea-ddns-ctrl-socket"
+ "socket-name": "kea-ddns-ctrl-socket"
}
},
"port": 53001,
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea-ddns-ctrl-socket"
+ "socket-name": "kea-ddns-ctrl-socket"
},
"tsig-keys": [],
"forward-ddns" : {},
// more. For detailed description, see Sections 8.8, 16 and 15.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
},
// Use Memfile lease database backend to store leases in a CSV file.
// description, see Sections 9.12, 16 and 15.
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
},
// Use Memfile lease database backend to store leases in a CSV file.
"dhcp4": {
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea4-ctrl-socket"
+ "socket-name": "kea4-ctrl-socket"
}
},
"dhcp6": {
"control-socket": {
"socket-type": "unix",
- "socket-name": "/tmp/kea6-ctrl-socket"
+ "socket-name": "kea6-ctrl-socket"
}
}
},
"dhcp4": {
"boot-update": true,
"control-socket": {
- "socket-name": "/tmp/kea4-ctrl-socket",
+ "socket-name": "kea4-ctrl-socket",
"socket-type": "unix",
"socket-url": "http://127.0.0.1:8000/"
},
AM_CPPFLAGS = -I$(top_srcdir)/src/lib -I$(top_builddir)/src/lib
AM_CPPFLAGS += $(BOOST_INCLUDES) $(CRYPTO_CFLAGS) $(CRYPTO_INCLUDES)
+control_socket_dir = @runstatedir@/@PACKAGE@
+AM_CPPFLAGS += -DCONTROL_SOCKET_DIR=\"$(control_socket_dir)\"
AM_CXXFLAGS = $(KEA_CXXFLAGS)
libkea_cfgclient_la_SOURCES += cmd_http_listener.cc cmd_http_listener.h
libkea_cfgclient_la_SOURCES += cmd_response_creator.cc cmd_response_creator.h
libkea_cfgclient_la_SOURCES += cmd_response_creator_factory.h
+libkea_cfgclient_la_SOURCES += unix_command_config.cc unix_command_config.h
libkea_cfgclient_la_LIBADD = $(top_builddir)/src/lib/http/libkea-http.la
libkea_cfgclient_la_LIBADD += $(top_builddir)/src/lib/dhcp/libkea-dhcp++.la
#include <asiolink/unix_domain_socket_acceptor.h>
#include <asiolink/unix_domain_socket_endpoint.h>
#include <config/command_mgr.h>
+#include <config/unix_command_config.h>
#include <cc/data.h>
#include <cc/command_interpreter.h>
#include <cc/json_feed.h>
isc_throw(BadSocketInfo, "'socket-name' parameter expected to be a string");
}
- socket_name_ = name->stringValue();
+ try {
+ socket_name_ = UnixCommandConfig::validatePath(name->stringValue());
+ } catch (const std::exception& ex) {
+ isc_throw(BadSocketInfo, "'socket-name' is invalid: " << ex.what());
+ }
// First let's open lock file.
std::string lock_name = getLockName();
doAccept();
} catch (const std::exception& ex) {
+ close(lock_fd);
+ static_cast<void>(::remove(getLockName().c_str()));
isc_throw(SocketError, ex.what());
}
}
AM_CPPFLAGS += $(BOOST_INCLUDES) $(CRYPTO_CFLAGS) $(CRYPTO_INCLUDES)
AM_CPPFLAGS += -DTEST_DATA_BUILDDIR=\"$(abs_top_builddir)/src/lib/config/tests\"
AM_CPPFLAGS += -DTEST_CA_DIR=\"$(srcdir)/../../asiolink/testutils/ca\"
+control_socket_dir = @runstatedir@/@PACKAGE@
+AM_CPPFLAGS += -DCONTROL_SOCKET_DIR=\"$(control_socket_dir)\"
AM_CXXFLAGS = $(KEA_CXXFLAGS)
run_unittests_SOURCES += cmd_http_listener_unittests.cc
run_unittests_SOURCES += cmd_response_creator_unittests.cc
run_unittests_SOURCES += cmd_response_creator_factory_unittests.cc
+run_unittests_SOURCES += unix_command_config_unittests.cc
run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
run_unittests_LDFLAGS = $(AM_LDFLAGS) $(CRYPTO_LDFLAGS) $(GTEST_LDFLAGS)
run_unittests_LDADD += $(top_builddir)/src/lib/dns/libkea-dns++.la
run_unittests_LDADD += $(top_builddir)/src/lib/cryptolink/libkea-cryptolink.la
run_unittests_LDADD += $(top_builddir)/src/lib/log/libkea-log.la
+run_unittests_LDADD += $(top_builddir)/src/lib/testutils/libkea-testutils.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/libkea-util.la
run_unittests_LDADD += $(top_builddir)/src/lib/exceptions/libkea-exceptions.la
#include <asiolink/io_service.h>
#include <config/base_command_mgr.h>
#include <config/command_mgr.h>
+#include <config/unix_command_config.h>
#include <config/hooked_command_mgr.h>
#include <cc/command_interpreter.h>
#include <hooks/hooks_manager.h>
#include <hooks/callout_handle.h>
#include <hooks/library_handle.h>
+#include <util/filesystem.h>
#include <string>
#include <vector>
using namespace isc::config;
using namespace isc::data;
using namespace isc::hooks;
+using namespace isc::util;
using namespace std;
// Test class for Command Manager
/// Default constructor
CommandMgrTest()
: io_service_(new IOService()) {
+ resetSocketPath();
CommandMgr::instance().setIOService(io_service_);
CommandMgr::instance().deregisterAll();
CommandMgr::instance().closeCommandSocket();
resetCalloutIndicators();
+ resetSocketPath();
}
- /// @brief Returns socket path (using either hardcoded path or env variable)
- /// @return path to the unix socket
- std::string getSocketPath() {
- std::string socket_path;
- const char* env = getenv("KEA_SOCKET_TEST_DIR");
- if (env) {
- socket_path = std::string(env) + "/test-socket";
- } else {
- socket_path = sandbox.join("test-socket");
- }
- return (socket_path);
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the hooks path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ UnixCommandConfig::getSocketPath(true,
+ (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
}
/// @brief Resets indicators related to callout invocation.
// This test verifies that a Unix socket can be opened properly and that input
// parameters (socket-type and socket-name) are verified.
TEST_F(CommandMgrTest, unixCreate) {
+ setSocketTestPath();
// Null pointer is obviously a bad idea.
EXPECT_THROW(CommandMgr::instance().openCommandSocket(ConstElementPtr()),
isc::config::BadSocketInfo);
EXPECT_THROW(CommandMgr::instance().openCommandSocket(socket_info),
isc::config::BadSocketInfo);
- socket_info->set("socket-name", Element::create(getSocketPath()));
+ socket_info->set("socket-name", Element::create("test-socket"));
EXPECT_NO_THROW(CommandMgr::instance().openCommandSocket(socket_info));
EXPECT_GE(CommandMgr::instance().getControlSocketFD(), 0);
// This test checks that when unix path is too long, the socket cannot be opened.
TEST_F(CommandMgrTest, unixCreateTooLong) {
+ setSocketTestPath();
ElementPtr socket_info = Element::fromJSON("{ \"socket-type\": \"unix\","
- "\"socket-name\": \"/tmp/toolongtoolongtoolongtoolongtoolongtoolong"
+ "\"socket-name\": \"toolongtoolongtoolongtoolongtoolongtoolong"
"toolongtoolongtoolongtoolongtoolongtoolongtoolongtoolongtoolong"
"\" }");
// Verifies that a socket cannot be concurrently opened more than once.
TEST_F(CommandMgrTest, exclusiveOpen) {
+ setSocketTestPath();
// Pass in valid parameters.
ElementPtr socket_info = Element::createMap();
socket_info->set("socket-type", Element::create("unix"));
- socket_info->set("socket-name", Element::create(getSocketPath()));
+ socket_info->set("socket-name", Element::create("test-socket"));
EXPECT_NO_THROW(CommandMgr::instance().openCommandSocket(socket_info));
EXPECT_GE(CommandMgr::instance().getControlSocketFD(), 0);
--- /dev/null
+// Copyright (C) 2025 Internet Systems Consortium, Inc. ("ISC")
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <config.h>
+
+#include <config/unix_command_config.h>
+#include <util/filesystem.h>
+#include <testutils/gtest_utils.h>
+#include <testutils/env_var_wrapper.h>
+
+using namespace isc;
+using namespace isc::config;
+using namespace isc::test;
+using namespace isc::util;
+using namespace std;
+
+namespace {
+
+/// @brief Test fixture for UNIX control socket configuration.
+class UnixCommandConfigTest : public ::testing::Test {
+public:
+ /// @brief Constructor.
+ UnixCommandConfigTest() {
+ setSocketTestPath();
+ }
+
+ /// @brief Destructor.
+ ~UnixCommandConfigTest() {
+ resetSocketPath();
+ }
+
+ /// @brief Sets the path in which the socket can be created.
+ /// @param explicit_path path to use as the hooks path.
+ void setSocketTestPath(const std::string explicit_path = "") {
+ UnixCommandConfig::getSocketPath(true,
+ (!explicit_path.empty() ?
+ explicit_path : TEST_DATA_BUILDDIR));
+
+ auto path = UnixCommandConfig::getSocketPath();
+ UnixCommandConfig::setSocketPathPerms(file::getPermissions(path));
+ }
+
+ /// @brief Resets the socket path to the default.
+ void resetSocketPath() {
+ UnixCommandConfig::getSocketPath(true);
+ UnixCommandConfig::setSocketPathPerms();
+ }
+};
+
+TEST(SocketPathTest, socketDir) {
+ EnvVarWrapper env("KEA_CONTROL_SOCKET_DIR");
+ env.setValue("");
+
+ auto path = UnixCommandConfig::getSocketPath(true);
+ ASSERT_EQ(path, std::string(CONTROL_SOCKET_DIR));
+
+ env.setValue(TEST_DATA_BUILDDIR);
+ path = UnixCommandConfig::getSocketPath(true);
+ ASSERT_EQ(path, std::string(TEST_DATA_BUILDDIR));
+}
+
+} // end of anonymous namespace
--- /dev/null
+// Copyright (C) 2025 Internet Systems Consortium, Inc. ("ISC")
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <config.h>
+
+#include <config/unix_command_config.h>
+#include <util/filesystem.h>
+#include <exceptions/exceptions.h>
+
+using namespace isc;
+using namespace isc::config;
+using namespace isc::util::file;
+using namespace std;
+
+namespace isc {
+namespace config {
+
+namespace {
+ // Singleton PathChecker to set and hold valid unix socket path.
+ PathCheckerPtr socket_path_checker_;
+
+};
+
+const mode_t UnixCommandConfig::DEFAULT_SOCKET_PATH_PERMS = (S_IRWXU | S_IRGRP | S_IXGRP);
+
+mode_t UnixCommandConfig::socket_path_perms_ = UnixCommandConfig::DEFAULT_SOCKET_PATH_PERMS;
+
+std::string
+UnixCommandConfig::getSocketPath(bool reset /* = false */,
+ const std::string explicit_path /* = "" */) {
+ if (!socket_path_checker_ || reset) {
+ socket_path_checker_.reset(new PathChecker(CONTROL_SOCKET_DIR,
+ "KEA_CONTROL_SOCKET_DIR"));
+ if (!explicit_path.empty()) {
+ socket_path_checker_->getPath(true, explicit_path);
+ }
+ }
+
+ return (socket_path_checker_->getPath());
+}
+
+std::string
+UnixCommandConfig::validatePath(const std::string socket_path,
+ bool enforce /* = true */) {
+ if (!socket_path_checker_) {
+ getSocketPath();
+ }
+
+ auto valid_path = socket_path_checker_->validatePath(socket_path, enforce);
+ if (enforce && !(socket_path_checker_->pathHasPermissions(socket_path_perms_))) {
+ isc_throw (BadValue,
+ "socket path:" << socket_path_checker_->getPath()
+ << " does not exist or does not have permssions = "
+ << std::oct << socket_path_perms_);
+ }
+
+ return (valid_path);
+}
+
+mode_t
+UnixCommandConfig::getSocketPathPerms() {
+ return (socket_path_perms_);
+}
+
+void
+UnixCommandConfig::setSocketPathPerms(mode_t perms
+ /* = DEFAULT_SOCKET_PATH_PERMS */) {
+ socket_path_perms_ = perms;
+}
+
+} // end of isc::config
+} // end of isc
--- /dev/null
+// Copyright (C) 2025 Internet Systems Consortium, Inc. ("ISC")
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef UNIX_COMMAND_CONFIG_H
+#define UNIX_COMMAND_CONFIG_H
+
+#include <util/filesystem.h>
+#include <string>
+
+namespace isc {
+namespace config {
+
+/// @brief UNIX command config aka UNIX control socket info class.
+class UnixCommandConfig {
+public:
+ /// @brief Defines the default permissions for unix socket parent directory.
+ static const mode_t DEFAULT_SOCKET_PATH_PERMS;
+
+ /// @brief Stores the default permissions for unix socket parent directory.
+ static mode_t socket_path_perms_;
+
+ /// @brief Constructor.
+ UnixCommandConfig() = default;
+
+ /// @brief Virtual destructor.
+ ~UnixCommandConfig() = default;
+
+ /// @brief Fetches the supported control socket path.
+ ///
+ /// The first call to this function with no arguments will set the default
+ /// path to either the value of CONTROL_SOCKET_DIR or the environment
+ /// variable KEA_CONTROL_SOCKET_DIR if it is defined. Subsequent calls with
+ /// no arguments will simply return this value.
+ ///
+ /// @param reset recalculate when true, defaults to false.
+ /// @param explicit_path set the default socket path to this value. This is
+ /// for testing purposes only.
+ ///
+ /// @return String containing the default socket path.
+ static std::string getSocketPath(bool reset = false,
+ const std::string explicit_path = "");
+
+ /// @brief Validates a path against the supported path for unix control
+ /// sockets.
+ ///
+ /// @param socket_path path to validate.
+ /// @param enforce enables validation against the supported path and
+ /// permissions.
+ /// If false simply returns the input path.
+ ///
+ /// @return validated path
+ static std::string validatePath(const std::string socket_path,
+ bool enforce = true);
+
+ /// @brief Fetches the required socket path permissions mask
+ ///
+ /// @return permissions mask
+ static mode_t getSocketPathPerms();
+
+ /// @brief Sets the required socket path permissions mask
+ ///
+ /// This is for testing purposes only.
+ /// @param perms permissions mask to use
+ static void setSocketPathPerms(mode_t perms = DEFAULT_SOCKET_PATH_PERMS);
+};
+
+} // end of isc::config namespace
+} // end of isc namespace
+#endif
return (::stat(path.c_str(), &statbuf) == 0);
}
+mode_t
+getPermissions(const std::string path) {
+ struct stat statbuf;
+ if (::stat(path.c_str(), &statbuf) < 0) {
+ return (0);
+ }
+
+ return (statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
+}
+
+bool
+hasPermissions(const std::string path, const mode_t& permissions) {
+ return (getPermissions(path) == permissions);
+}
+
bool
isDir(string const& path) {
struct stat statbuf;
return (valid_path);
}
+bool
+PathChecker::pathHasPermissions(mode_t permissions) {
+ return(hasPermissions(path_, permissions));
+}
+
} // namespace file
} // namespace util
} // namespace isc
bool
isDir(const std::string& path);
+/// @brief Fetches the file permissions mask.
+///
+/// @param path The path being checked.
+/// @return File permissios mask or 0 if the path does not exist.
+mode_t
+getPermissions(const std::string path);
+
+/// @brief Check if there if file or directory has the given permissions.
+///
+/// @param path The path being checked.
+/// @param permissions mask of expected permissions.
+///
+/// @return True if the path points to a file or a directory, false otherwise.
+bool
+hasPermissions(const std::string path, const mode_t& permissions);
+
/// @brief Check if there is a file at the given path.
///
/// @param path The path being checked.
std::string validatePath(const std::string input_path_str,
bool enforce_path = true) const;
+ /// @brief Tests that the supported path has the given permissions.
+ ///
+ /// @param permissions mode_t mask of required permissions.
+ /// @return True if the path's permissions exactly match the permissions
+ /// parameter.
+ bool pathHasPermissions(mode_t permissions);
+
/// @brief Fetches the default path.
std::string getDefaultPath() const {
return (default_path_);
}
}
+/// @brief Check hasPermissions.
+TEST_F(FileUtilTest, hasPermissions) {
+ const std::string path = ABS_SRCDIR "/filesystem_unittests.cc";
+ ASSERT_TRUE(isFile(path));
+ mode_t current_permissions = getPermissions(path);
+ EXPECT_TRUE(hasPermissions(path, current_permissions));
+ current_permissions = ~current_permissions;
+ EXPECT_FALSE(hasPermissions(path, current_permissions));
+}
+
+
} // namespace
projects / thirdparty / kea.git / commitdiff
