Repurpose into VIS clientneedlefish_13.93.0needlefish/13.93.013.93.0

Repurpose repository for a spiritual successor of the previous
binding.  The replacement is a daemon that demonstrates servicing
HVAC actuators from the VSS schema via VIS signals from KUKSA.val.
Currently the connection to KUKSA.val is websocket based using the
boost::asio framework, but the plan is to migrate to grpc as that
becomes more robust in KUKSA.val.

Notable changes:
- New code is completely C++, partly to leverage using Boost, but
  also to futureproof future work with grpc.
- Switch from CMake to meson for ease of development and some
  degree of futureproofing.
- Use with systemd is assumed; behavior follows the systemd
  daemon guidelines barring the use of journald logging prefixes,
  which may be addressed with future work.  A systemd unit is
  also installed as part of the build.
- SPDX license headers using SPDX "short identifiers" are used in
  source files rather than the full copyright headers used in the
  previous codebase.  This follows the direction that projects such
  as the Linux kernel are going in.
- The JSON configuration file for the LED control files for the
  demo platform has been migrated to a INI format configuration
  file matching what has been done for the VIS client configuration
  in other recent work.

Bug-AGL: SPEC-4409

Signed-off-by: Scott Murray <scott.murray@konsulko.com>
Change-Id: Ic2061bca9670b1e461d6f1e6591471e257fff5b9

1 files changed, 157 insertions, 0 deletions

diff --git a/src/vis-config.cpp b/src/vis-config.cpp
new file mode 100644
index 0000000..b8d9266
--- /dev/null
+++ b/src/vis-config.cpp
@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "vis-config.hpp"
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/ini_parser.hpp>
+#include <boost/filesystem.hpp>
+
+namespace property_tree = boost::property_tree;
+namespace filesystem = boost::filesystem;
+
+#define DEFAULT_CLIENT_KEY_FILE  "/etc/kuksa-val/Client.key"
+#define DEFAULT_CLIENT_CERT_FILE "/etc/kuksa-val/Client.pem"
+#define DEFAULT_CA_CERT_FILE     "/etc/kuksa-val/CA.pem"
+
+
+VisConfig::VisConfig(const std::string &hostname,
+		     const unsigned port,
+		     const std::string &clientKey,
+		     const std::string &clientCert,
+		     const std::string &caCert,
+		     const std::string &authToken,
+		     bool verifyPeer) :
+	m_hostname(hostname),
+	m_port(port),
+	m_clientKey(clientKey),
+	m_clientCert(clientCert),
+	m_caCert(caCert),
+	m_authToken(authToken),
+	m_verifyPeer(verifyPeer),
+	m_verbose(0),
+	m_valid(true)
+{
+	// Potentially could do some certificate validation here...
+}
+
+VisConfig::VisConfig(const std::string &appname) :
+	m_valid(false)
+{
+	std::string config("/etc/xdg/AGL/");
+	config += appname;
+	config += ".conf";
+	char *home = getenv("XDG_CONFIG_HOME");
+	if (home) {
+		config = home;
+		config += "/AGL/";
+		config += appname;
+		config += ".conf";
+	}
+
+	std::cout << "Using configuration " << config << std::endl;
+	property_tree::ptree pt;
+	try {
+		property_tree::ini_parser::read_ini(config, pt);
+	}
+	catch (std::exception &ex) {
+		std::cerr << "Could not read " << config << std::endl;
+		return;
+	}
+	const property_tree::ptree &settings =
+		pt.get_child("vis-client", property_tree::ptree());
+
+	m_hostname = settings.get("server", "localhost");
+	std::stringstream ss;
+	ss << m_hostname;
+	ss >> std::quoted(m_hostname);
+	if (m_hostname.empty()) {
+		std::cerr << "Invalid server hostname" << std::endl;
+		return;
+	}
+
+	m_port = settings.get("port", 8090);
+	if (m_port == 0) {
+		std::cerr << "Invalid server port" << std::endl;
+		return;
+	}
+
+	// Default to disabling peer verification for now to be able
+        // to use the default upstream KUKSA.val certificates for
+	// testing.  Wrangling server and CA certificate generation
+	// and management to be able to verify will require further
+	// investigation.
+	m_verifyPeer = settings.get("verify-server", false);
+
+	std::string keyFileName = settings.get("key", DEFAULT_CLIENT_KEY_FILE);
+	std::stringstream().swap(ss);
+	ss << keyFileName;
+	ss >> std::quoted(keyFileName);
+	ss.str("");
+	if (keyFileName.empty()) {
+		std::cerr << "Invalid client key filename" << std::endl;
+		return;
+	}
+	filesystem::load_string_file(keyFileName, m_clientKey);
+	if (m_clientKey.empty()) {
+		std::cerr << "Invalid client key file" << std::endl;
+		return;
+	}
+
+	std::string certFileName = settings.get("certificate", DEFAULT_CLIENT_CERT_FILE);
+	std::stringstream().swap(ss);
+	ss << certFileName;
+	ss >> std::quoted(certFileName);
+	if (certFileName.empty()) {
+		std::cerr << "Invalid client certificate filename" << std::endl;
+		return;
+	}
+	filesystem::load_string_file(certFileName, m_clientCert);
+	if (m_clientCert.empty()) {
+		std::cerr << "Invalid client certificate file" << std::endl;
+		return;
+	}
+
+	std::string caCertFileName = settings.get("ca-certificate", DEFAULT_CA_CERT_FILE);
+	std::stringstream().swap(ss);
+	ss << caCertFileName;
+	ss >> std::quoted(caCertFileName);
+	if (caCertFileName.empty()) {
+		std::cerr << "Invalid CA certificate filename" << std::endl;
+		return;
+	}
+	filesystem::load_string_file(caCertFileName, m_caCert);
+	if (m_caCert.empty()) {
+		std::cerr << "Invalid CA certificate file" << std::endl;
+		return;
+	}
+
+	std::string authTokenFileName = settings.get("authorization", "");
+	std::stringstream().swap(ss);
+	ss << authTokenFileName;
+	ss >> std::quoted(authTokenFileName);
+	if (authTokenFileName.empty()) {
+		std::cerr << "Invalid authorization token filename" << std::endl;
+		return;
+	}
+	filesystem::load_string_file(authTokenFileName, m_authToken);
+	if (m_authToken.empty()) {
+		std::cerr << "Invalid authorization token file" << std::endl;
+		return;
+	}
+
+	m_verbose = 0;
+	std::string verbose = settings.get("verbose", "");
+	std::stringstream().swap(ss);
+	ss << verbose;
+	ss >> std::quoted(verbose);
+	if (!verbose.empty()) {
+		if (verbose == "true" || verbose == "1")
+			m_verbose = 1;
+		if (verbose == "2")
+			m_verbose = 2;
+	}
+
+	m_valid = true;
+}