validate CSMS-URL: opt. schema must fit with security-profile; chargepoint-ID deprecated in URL

config/v201/config.json

@@ -595,6 +595,12 @@
                     "Actual": "1"
                 }
             },
+            "Identity": {
+                "variable_name": "Identity",
+                "attributes": {
+                    "Actual": "cp001"
+                }
+            },
             "BasicAuthPassword": {
                 "variable_name": "BasicAuthPassword",
                 "attributes": {

include/ocpp/common/websocket/websocket_base.hpp

@@ -9,17 +9,17 @@
 #include <thread>
 
 #include <everest/timer.hpp>
-
-#include <ocpp/common/types.hpp>
-
 #include <websocketpp/client.hpp>
 #include <websocketpp/config/asio_client.hpp>
 
+#include <ocpp/common/types.hpp>
+#include <ocpp/common/websocket/websocket_uri.hpp>
+
 namespace ocpp {
 
 struct WebsocketConnectionOptions {
     OcppProtocolVersion ocpp_version;
-    std::string cs_uri;
+    std::string csms_uri;  // the URI of the CSMS
     int security_profile;
     std::string chargepoint_id;
     std::optional<std::string> authorization_key;
@@ -49,7 +49,7 @@ class WebsocketBase {
     std::function<void(const std::string& message)> message_callback;
     websocketpp::lib::shared_ptr<boost::asio::steady_timer> reconnect_timer;
     std::unique_ptr<Everest::SteadyTimer> ping_timer;
-    std::string uri;
+    ocpp::Uri uri;  // to be set in derived classes
     websocketpp::connection_hdl handle;
     std::mutex reconnect_mutex;
     std::mutex connection_mutex;
@@ -92,7 +92,8 @@ class WebsocketBase {
     virtual bool connect() = 0;
 
     /// \brief sets this connection_options to the given \p connection_options and resets the connection_attempts
-    void set_connection_options(const WebsocketConnectionOptions& connection_options);
+    virtual void set_connection_options(const WebsocketConnectionOptions& connection_options) = 0;
+    void set_connection_options_base(const WebsocketConnectionOptions& connection_options);
 
     /// \brief reconnect the websocket after the delay
     virtual void reconnect(std::error_code reason, long delay) = 0;

include/ocpp/common/websocket/websocket_plain.hpp

@@ -41,6 +41,8 @@ class WebsocketPlain final : public WebsocketBase {
     /// \brief Called when a plaintext websocket connection fails to be established
     void on_fail_plain(client* c, websocketpp::connection_hdl hdl);
 
+    void set_connection_options(const WebsocketConnectionOptions& connection_options) override;
+
 public:
     /// \brief Creates a new WebsocketPlain object with the providede \p connection_options
     explicit WebsocketPlain(const WebsocketConnectionOptions& connection_options);

include/ocpp/common/websocket/websocket_tls.hpp

@@ -6,6 +6,7 @@
 #include <websocketpp/client.hpp>
 #include <websocketpp/config/asio_client.hpp>
 
+#include <ocpp/common/evse_security.hpp>
 #include <ocpp/common/websocket/websocket_base.hpp>
 
 namespace ocpp {
@@ -25,12 +26,6 @@ class WebsocketTLS final : public WebsocketBase {
     tls_client wss_client;
     std::shared_ptr<EvseSecurity> evse_security;
     websocketpp::lib::shared_ptr<websocketpp::lib::thread> websocket_thread;
-
-    /// \brief Extracts the hostname from the provided \p uri
-    /// FIXME(kai): this only works with a very limited subset of hostnames and should be extended to work spec conform
-    /// \returns the extracted hostname
-    std::string get_hostname(std::string uri);
-
     /// \brief Called when a TLS websocket connection gets initialized, manages the supported TLS versions, cipher lists
     /// and how verification of the server certificate is handled
     tls_context on_tls_init(std::string hostname, websocketpp::connection_hdl hdl, int32_t security_profile);
@@ -50,6 +45,8 @@ class WebsocketTLS final : public WebsocketBase {
     /// \brief Called when a TLS websocket connection fails to be established
     void on_fail_tls(tls_client* c, websocketpp::connection_hdl hdl);
 
+    void set_connection_options(const WebsocketConnectionOptions& connection_options) override;
+
 public:
     /// \brief Creates a new Websocket object with the providede \p connection_options
     explicit WebsocketTLS(const WebsocketConnectionOptions& connection_options,

include/ocpp/common/websocket/websocket_uri.hpp

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
+#ifndef OCPP_WEBSOCKET_URI_HPP
+#define OCPP_WEBSOCKET_URI_HPP
+
+#include <ocpp/types/simple.hpp>
+#include <string>
+#include <websocketpp/uri.hpp>
+
+namespace ocpp {
+
+class Uri {
+public:
+    Uri(){};
+
+    void init(bool secure, std::string host, int port, std::string path); // TODO should return an error if invalid
+
+    // if a `chargepoint_id` is given, it will be checked that it is the same as the one in the URI-path, if set
+    // if invalid, it throws `invalid_argument` exception
+    static Uri parse_from_string(std::string const& uri,
+                                 ChargepointId chargepoint_id); // TODO should return an `expected<>`
+
+    void set_secure(bool secure) {
+        this->secure = secure;
+    }
+
+    std::string get_hostname() {
+        return this->host;
+    }
+
+    std::string string() {
+        auto uri = get_websocketpp_uri();
+        return uri.str();
+    }
+
+    websocketpp::uri get_websocketpp_uri() { // FIXME: wrap needed `websocketpp:uri` functionality inside `Uri`
+        return websocketpp::uri(this->secure, this->host, this->port, this->path);
+    }
+
+private:
+    Uri(bool secure, std::string host, uint16_t port, std::string path) :
+        secure(secure), host(host), port(port), path(path) {
+    }
+
+    bool secure;
+    std::string host;
+    uint16_t port;
+    std::string path;
+};
+
+} // namespace ocpp
+
+#endif // OCPP_WEBSOCKET_URI_HPP */

include/ocpp/types/simple.hpp

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2023 Pionix GmbH and Contributors to EVerest
+
+#ifndef OCPP_TYPES_SIMPLE_HPP
+#define OCPP_TYPES_SIMPLE_HPP
+
+#include <string>
+
+typedef std::string ChargepointId;
+
+#endif // OCPP_TYPES_SIMPLE_HPP

lib/ocpp/common/websocket/CMakeLists.txt

@@ -2,6 +2,7 @@
 target_sources(ocpp
     PRIVATE
         websocket_base.cpp
+        websocket_uri.cpp
         websocket_plain.cpp
         websocket_tls.cpp
         websocket.cpp

lib/ocpp/common/websocket/websocket.cpp

@@ -15,10 +15,8 @@ Websocket::Websocket(const WebsocketConnectionOptions& connection_options, std::
                      std::shared_ptr<MessageLogging> logging) :
     logging(logging) {
     if (connection_options.security_profile <= 1) {
-        EVLOG_debug << "Creating plaintext websocket based on the provided URI: " << connection_options.cs_uri;
         this->websocket = std::make_unique<WebsocketPlain>(connection_options);
     } else if (connection_options.security_profile >= 2) {
-        EVLOG_debug << "Creating TLS websocket based on the provided URI: " << connection_options.cs_uri;
         this->websocket = std::make_unique<WebsocketTLS>(connection_options, evse_security);
     }
 }

lib/ocpp/common/websocket/websocket_base.cpp

@@ -28,7 +28,9 @@ WebsocketBase::WebsocketBase(const WebsocketConnectionOptions& connection_option
 WebsocketBase::~WebsocketBase() {
 }
 
-void WebsocketBase::set_connection_options(const WebsocketConnectionOptions& connection_options) {
+void WebsocketBase::set_connection_options_base(const WebsocketConnectionOptions& connection_options) {
+    this->uri = Uri::parse_from_string(connection_options.csms_uri, connection_options.chargepoint_id);
+
     this->connection_attempts = 0;
     this->connection_options = connection_options;
 }

lib/ocpp/common/websocket/websocket_plain.cpp

@@ -2,6 +2,7 @@
 // Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
 #include <everest/logging.hpp>
 
+#include <memory>
 #include <ocpp/common/websocket/websocket_plain.hpp>
 
 #include <boost/optional/optional.hpp>
@@ -10,27 +11,35 @@ namespace ocpp {
 
 WebsocketPlain::WebsocketPlain(const WebsocketConnectionOptions& connection_options) :
     WebsocketBase(connection_options) {
+
+    set_connection_options(connection_options);
+
+    EVLOG_debug << "Initialised WebsocketPlain with URI: " << this->uri.string();
+}
+
+void WebsocketPlain::set_connection_options(const WebsocketConnectionOptions& connection_options) {
+    set_connection_options_base(connection_options);  // initialises this->uri, too
+
+    this->uri.set_secure(false);
 }
 
 bool WebsocketPlain::connect() {
     if (!this->initialized()) {
         return false;
     }
-    const auto uri = this->connection_options.cs_uri.insert(0, "ws://");
 
-    EVLOG_info << "Connecting to plain websocket at uri: " << uri
+    EVLOG_info << "Connecting to plain websocket at uri: " << this->uri.string()
                << " with profile: " << this->connection_options.security_profile;
 
     this->ws_client.clear_access_channels(websocketpp::log::alevel::all);
     this->ws_client.clear_error_channels(websocketpp::log::elevel::all);
     this->ws_client.init_asio();
     this->ws_client.start_perpetual();
-    this->uri = uri;
 
     websocket_thread.reset(new websocketpp::lib::thread(&client::run, &this->ws_client));
 
     this->reconnect_callback = [this](const websocketpp::lib::error_code& ec) {
-        EVLOG_info << "Reconnecting to plain websocket at uri: " << this->connection_options.cs_uri
+        EVLOG_info << "Reconnecting to plain websocket at uri: " << this->connection_options.csms_uri
                    << " with profile: " << this->connection_options.security_profile;
 
         // close connection before reconnecting
@@ -120,7 +129,7 @@ void WebsocketPlain::connect_plain() {
 
     websocketpp::lib::error_code ec;
 
-    client::connection_ptr con = this->ws_client.get_connection(this->uri, ec);
+    const client::connection_ptr con = this->ws_client.get_connection(std::make_shared<websocketpp::uri>(this->uri.get_websocketpp_uri()), ec);
 
     if (ec) {
         EVLOG_error << "Connection initialization error for plain websocket: " << ec.message();

lib/ocpp/common/websocket/websocket_tls.cpp

@@ -1,38 +1,49 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
-#include <boost/optional/optional.hpp>
 
-#include <everest/logging.hpp>
+#include <memory>
 
 #include <ocpp/common/evse_security.hpp>
+#include <ocpp/common/websocket/websocket_uri.hpp>
 #include <ocpp/common/websocket/websocket_tls.hpp>
 
+#include <everest/logging.hpp>
+
 namespace ocpp {
 
 WebsocketTLS::WebsocketTLS(const WebsocketConnectionOptions& connection_options,
                            std::shared_ptr<EvseSecurity> evse_security) :
     WebsocketBase(connection_options), evse_security(evse_security) {
+
+    EVLOG_debug << "Initialised WebsocketTLS with URI: " << this->uri.string();
+}
+
+void WebsocketTLS::set_connection_options(const WebsocketConnectionOptions& connection_options) {
+    set_connection_options_base(connection_options);  // initialises this->uri, too
+
+    this->uri.set_secure(true);
 }
 
 bool WebsocketTLS::connect() {
     if (!this->initialized()) {
         return false;
     }
-    this->uri = this->connection_options.cs_uri.insert(0, "wss://");
-    EVLOG_info << "Connecting TLS websocket to uri: " << this->uri << " with profile "
-               << this->connection_options.security_profile;
+
+    EVLOG_info << "Connecting TLS websocket to uri: " << this->uri.string()
+               << " with security-profile " << this->connection_options.security_profile;
+
     this->wss_client.clear_access_channels(websocketpp::log::alevel::all);
     this->wss_client.clear_error_channels(websocketpp::log::elevel::all);
     this->wss_client.init_asio();
     this->wss_client.start_perpetual();
     websocket_thread.reset(new websocketpp::lib::thread(&tls_client::run, &this->wss_client));
 
     this->wss_client.set_tls_init_handler(
-        websocketpp::lib::bind(&WebsocketTLS::on_tls_init, this, this->get_hostname(this->uri),
+        websocketpp::lib::bind(&WebsocketTLS::on_tls_init, this, this->uri.get_hostname(),
                                websocketpp::lib::placeholders::_1, this->connection_options.security_profile));
 
     this->reconnect_callback = [this](const websocketpp::lib::error_code& ec) {
-        EVLOG_info << "Reconnecting to TLS websocket at uri: " << this->connection_options.cs_uri
+        EVLOG_info << "Reconnecting to TLS websocket at uri: " << this->connection_options.csms_uri
                    << " with profile: " << this->connection_options.security_profile;
 
         // close connection before reconnecting
@@ -117,22 +128,6 @@ void WebsocketTLS::reconnect(std::error_code reason, long delay) {
     // https://github.com/zaphoyd/websocketpp/blob/master/websocketpp/close.hpp
 }
 
-std::string WebsocketTLS::get_hostname(std::string uri) {
-    // FIXME(kai): This only works with a very limited subset of hostnames!
-    std::string start = "wss://";
-    std::string stop = "/";
-    std::string port = ":";
-    auto hostname_start_pos = start.length();
-    auto hostname_end_pos = uri.find_first_of(stop, hostname_start_pos);
-
-    auto hostname_with_port = uri.substr(hostname_start_pos, hostname_end_pos - hostname_start_pos);
-    auto port_pos = hostname_with_port.find_first_of(port);
-    if (port_pos != std::string::npos) {
-        return hostname_with_port.substr(0, port_pos);
-    }
-    return hostname_with_port;
-}
-
 tls_context WebsocketTLS::on_tls_init(std::string hostname, websocketpp::connection_hdl hdl, int32_t security_profile) {
     tls_context context = websocketpp::lib::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
 
@@ -212,7 +207,7 @@ tls_context WebsocketTLS::on_tls_init(std::string hostname, websocketpp::connect
 void WebsocketTLS::connect_tls() {
     websocketpp::lib::error_code ec;
 
-    tls_client::connection_ptr con = this->wss_client.get_connection(this->uri, ec);
+    const tls_client::connection_ptr con = this->wss_client.get_connection(std::make_shared<websocketpp::uri>(this->uri.get_websocketpp_uri()), ec);
 
     if (ec) {
         EVLOG_error << "Connection initialization error for TLS websocket: " << ec.message();

lib/ocpp/common/websocket/websocket_uri.cpp

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2023 Pionix GmbH and Contributors to EVerest
+
+#include "ocpp/types/simple.hpp"
+#include <ocpp/common/websocket/websocket_uri.hpp>
+
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <stdexcept>
+#include <string>
+#include <websocketpp/uri.hpp>
+
+namespace ocpp {
+
+Uri Uri::parse_from_string(std::string const& uri, ChargepointId chargepoint_id) {
+    auto uri_temp = websocketpp::uri(uri);
+
+    if (!uri_temp.get_valid()) {
+        throw std::invalid_argument("Uri constructor: given `uri` is invalid");
+    }
+
+    const auto& hostname = uri_temp.get_host();
+    if (!hostname.empty()) {
+        if (hostname != chargepoint_id) {
+            throw std::invalid_argument("Uri constructor: the chargepoint-ID in the `uri`-path is different to the defined one");
+        }
+
+        chargepoint_id = hostname;
+    }
+
+    auto uri_return = Uri(uri_temp.get_secure(), uri_temp.get_host(), uri_temp.get_port(), uri_temp.get_resource());
+
+    return uri_return;
+}
+
+} // namespace ocpp