Changes on websocket interface to use a new defined enum.

Signed-off-by: Maaike Zijderveld <m.zijderveld@alfen.nl>

Author: maaikez

include/ocpp/common/types.hpp

@@ -602,6 +602,38 @@ enum class MessageDirection {
     ChargingStationToCSMS
 };
 
+///
+/// \brief Reason why a websocket closes its connection
+///
+enum class WebsocketCloseReason : uint8_t
+{
+    /// Normal closure, meaning that the purpose for which the connection was
+    /// established has been fulfilled.
+    Normal = 1,
+    /// Close the connection with a forced TCP drop.
+    /**
+     * This special value requests that the WebSocket connection be closed by
+     * forcibly dropping the TCP connection. This will leave the other side of
+     * the connection with a broken connection and some expensive timeouts. this
+     * should not be done except in extreme cases or in cases of malicious
+     * remote endpoints.
+     */
+    ForceTcpDrop,
+    /// The endpoint was "going away", such as a server going down or a browser
+    /// navigating away from a page.
+    GoingAway,
+    /// A dummy value to indicate that the connection was closed abnormally.
+    /**
+     * In such a case there was no close frame to extract a value from. This
+     * value is illegal on the wire.
+     */
+    AbnormalClose,
+    /// Indicates that the service is restarted. A client may reconnect and if
+    /// if it chooses to do so, should reconnect using a randomized delay of
+    /// 5-30s
+    ServiceRestart
+};
+
 } // namespace ocpp
 
 #endif

include/ocpp/common/websocket/websocket.hpp

@@ -9,6 +9,10 @@
 #include <ocpp/common/websocket/websocket_tls.hpp>
 
 namespace ocpp {
+
+class WebsocketBase;
+struct WebsocketConnectionOptions;
+
 ///
 /// \brief contains a websocket abstraction that can connect to TLS and non-TLS websocket endpoints
 ///
@@ -18,7 +22,7 @@ class Websocket {
     std::unique_ptr<WebsocketBase> websocket;
     std::function<void(const int security_profile)> connected_callback;
     std::function<void()> disconnected_callback;
-    std::function<void(const websocketpp::close::status::value reason)> closed_callback;
+    std::function<void(const WebsocketCloseReason reason)> closed_callback;
     std::function<void(const std::string& message)> message_callback;
     std::shared_ptr<MessageLogging> logging;
 
@@ -34,7 +38,7 @@ class Websocket {
     void set_connection_options(const WebsocketConnectionOptions& connection_options);
 
     /// \brief disconnect the websocket
-    void disconnect(websocketpp::close::status::value code);
+    void disconnect(const WebsocketCloseReason code);
 
     // \brief reconnects the websocket after the delay
     void reconnect(std::error_code reason, long delay);
@@ -50,7 +54,7 @@ class Websocket {
 
     /// \brief register a \p callback that is called when the websocket connection has been closed and will not attempt
     /// to reconnect
-    void register_closed_callback(const std::function<void(const websocketpp::close::status::value reason)>& callback);
+    void register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback);
 
     /// \brief register a \p callback that is called when the websocket receives a message
     void register_message_callback(const std::function<void(const std::string& message)>& callback);

include/ocpp/common/websocket/websocket_base.hpp

@@ -36,6 +36,7 @@ struct WebsocketConnectionOptions {
     std::optional<std::string> hostName;
     bool verify_csms_common_name;
     bool use_tpm_tls;
+    std::optional<std::string> iface_or_ip;    ///< The interface of the connection or the ip address of the interface
 };
 
 ///
@@ -47,7 +48,7 @@ class WebsocketBase {
     WebsocketConnectionOptions connection_options;
     std::function<void(const int security_profile)> connected_callback;
     std::function<void()> disconnected_callback;
-    std::function<void(const websocketpp::close::status::value reason)> closed_callback;
+    std::function<void(const WebsocketCloseReason reason)> closed_callback;
     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;
@@ -101,13 +102,13 @@ class WebsocketBase {
     virtual void reconnect(std::error_code reason, long delay) = 0;
 
     /// \brief disconnect the websocket
-    void disconnect(websocketpp::close::status::value code);
+    void disconnect(WebsocketCloseReason code);
 
     /// \brief indicates if the websocket is connected
     bool is_connected();
 
     /// \brief closes the websocket
-    virtual void close(websocketpp::close::status::value code, const std::string& reason) = 0;
+    virtual void close(WebsocketCloseReason code, const std::string& reason) = 0;
 
     /// \brief register a \p callback that is called when the websocket is connected successfully
     void register_connected_callback(const std::function<void(const int security_profile)>& callback);
@@ -117,7 +118,7 @@ class WebsocketBase {
 
     /// \brief register a \p callback that is called when the websocket connection has been closed and will not attempt
     /// to reconnect
-    void register_closed_callback(const std::function<void(const websocketpp::close::status::value reason)>& callback);
+    void register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback);
 
     /// \brief register a \p callback that is called when the websocket receives a message
     void register_message_callback(const std::function<void(const std::string& message)>& callback);

include/ocpp/common/websocket/websocket_plain.hpp

@@ -60,7 +60,7 @@ class WebsocketPlain final : public WebsocketBase {
     void reconnect(std::error_code reason, long delay) override;
 
     /// \brief Closes a plaintext websocket connection
-    void close(websocketpp::close::status::value code, const std::string& reason) override;
+    void close(WebsocketCloseReason code, const std::string& reason) override;
 
     /// \brief send a \p message over the websocket
     /// \returns true if the message was sent successfully

include/ocpp/common/websocket/websocket_tls.hpp

@@ -66,7 +66,7 @@ class WebsocketTLS final : public WebsocketBase {
     void reconnect(std::error_code reason, long delay) override;
 
     /// \brief closes the websocket
-    void close(websocketpp::close::status::value code, const std::string& reason) override;
+    void close(WebsocketCloseReason code, const std::string& reason) override;
 
     /// \brief send a \p message over the websocket
     /// \returns true if the message was sent successfully

include/ocpp/common/websocket/websocket_tls_tpm.hpp

@@ -33,7 +33,7 @@ class WebsocketTlsTPM final : public WebsocketBase {
     void reconnect(std::error_code reason, long delay) override;
 
     /// \brief closes the websocket
-    void close(websocketpp::close::status::value code, const std::string& reason) override;
+    void close(WebsocketCloseReason code, const std::string& reason) override;
 
     /// \brief send a \p message over the websocket
     /// \returns true if the message was sent successfully

include/ocpp/v201/charge_point.hpp

@@ -588,7 +588,7 @@ class ChargePoint : ocpp::ChargingStationBase {
 
     /// \brief Disconnects the the websocket connection to the CSMS if it is connected
     /// \param code Optional websocket close status code (default: normal).
-    void disconnect_websocket(websocketpp::close::status::value code = websocketpp::close::status::normal);
+    void disconnect_websocket(WebsocketCloseReason code = WebsocketCloseReason::Normal);
 
     /// \brief Chargepoint notifies about new firmware update status firmware_update_status. This function should be
     ///        called during a Firmware Update to indicate the current firmware_update_status.

lib/ocpp/common/websocket/websocket.cpp

@@ -42,7 +42,7 @@ void Websocket::set_connection_options(const WebsocketConnectionOptions& connect
     this->websocket->set_connection_options(connection_options);
 }
 
-void Websocket::disconnect(websocketpp::close::status::value code) {
+void Websocket::disconnect(const WebsocketCloseReason code) {
     this->logging->sys("Disconnecting");
     this->websocket->disconnect(code);
 }
@@ -75,10 +75,10 @@ void Websocket::register_disconnected_callback(const std::function<void()>& call
 }
 
 void Websocket::register_closed_callback(
-    const std::function<void(const websocketpp::close::status::value reason)>& callback) {
+    const std::function<void(const WebsocketCloseReason reason)>& callback) {
     this->closed_callback = callback;
     this->websocket->register_closed_callback(
-        [this](const websocketpp::close::status::value reason) { this->closed_callback(reason); });
+        [this](const WebsocketCloseReason reason) { this->closed_callback(reason); });
 }
 
 void Websocket::register_message_callback(const std::function<void(const std::string& message)>& callback) {

lib/ocpp/common/websocket/websocket_base.cpp

@@ -43,7 +43,7 @@ void WebsocketBase::register_disconnected_callback(const std::function<void()>&
 }
 
 void WebsocketBase::register_closed_callback(
-    const std::function<void(const websocketpp::close::status::value reason)>& callback) {
+    const std::function<void(const WebsocketCloseReason reason)>& callback) {
     this->closed_callback = callback;
 }
 
@@ -68,12 +68,12 @@ bool WebsocketBase::initialized() {
     return true;
 }
 
-void WebsocketBase::disconnect(websocketpp::close::status::value code) {
+void WebsocketBase::disconnect(WebsocketCloseReason code) {
     if (!this->initialized()) {
         EVLOG_error << "Cannot disconnect a websocket that was not initialized";
         return;
     }
-    if (code == websocketpp::close::status::normal) {
+    if (code == WebsocketCloseReason::Normal) {
         this->shutting_down = true;
     }
     if (this->reconnect_timer) {
@@ -162,7 +162,7 @@ void WebsocketBase::on_pong_timeout(websocketpp::connection_hdl hdl, std::string
     if (!this->reconnecting) {
         EVLOG_info << "Reconnecting because of a pong timeout after " << this->connection_options.pong_timeout_s << "s";
         this->reconnecting = true;
-        this->close(websocketpp::close::status::going_away, "Pong timeout");
+        this->close(WebsocketCloseReason::GoingAway, "Pong timeout");
     }
 }
 

lib/ocpp/common/websocket/websocket_plain.cpp

@@ -58,7 +58,7 @@ bool WebsocketPlain::connect() {
         if (this->m_is_connected) {
             try {
                 EVLOG_info << "Closing websocket connection before reconnecting";
-                this->ws_client.close(this->handle, websocketpp::close::status::normal, "");
+                this->ws_client.close(this->handle, WebsocketCloseReason::Normal, "");
             } catch (std::exception& e) {
                 EVLOG_error << "Error on plain close: " << e.what();
             }
@@ -107,7 +107,7 @@ void WebsocketPlain::reconnect(std::error_code reason, long delay) {
         if (this->m_is_connected) {
             try {
                 EVLOG_info << "Closing websocket connection before reconnecting";
-                this->ws_client.close(this->handle, websocketpp::close::status::normal, "");
+                this->ws_client.close(this->handle, WebsocketCloseReason::Normal, "");
             } catch (std::exception& e) {
                 EVLOG_error << "Error on plain close: " << e.what();
             }
@@ -125,7 +125,7 @@ void WebsocketPlain::reconnect(std::error_code reason, long delay) {
     // TODO(kai): complete error handling, especially making sure that a reconnect is only attempted in reasonable
     // circumstances
     switch (reason.value()) {
-    case websocketpp::close::status::force_tcp_drop:
+    case WebsocketCloseReason::ForceTcpDrop:
         /* code */
         break;
 
@@ -223,7 +223,7 @@ void WebsocketPlain::on_close_plain(client* c, websocketpp::connection_hdl hdl)
                << websocketpp::close::status::get_string(con->get_remote_close_code())
                << "), reason: " << con->get_remote_close_reason();
     // dont reconnect on normal code
-    if (con->get_remote_close_code() != websocketpp::close::status::normal) {
+    if (con->get_remote_close_code() != WebsocketCloseReason::Normal) {
         this->reconnect(error_code, this->get_reconnect_interval());
     } else {
         this->closed_callback(con->get_remote_close_code());
@@ -246,11 +246,11 @@ void WebsocketPlain::on_fail_plain(client* c, websocketpp::connection_hdl hdl) {
         this->connection_attempts <= this->connection_options.max_connection_attempts) {
         this->reconnect(ec, this->get_reconnect_interval());
     } else {
-        this->close(websocketpp::close::status::normal, "Connection failed");
+        this->close(WebsocketCloseReason::Normal, "Connection failed");
     }
 }
 
-void WebsocketPlain::close(websocketpp::close::status::value code, const std::string& reason) {
+void WebsocketPlain::close(WebsocketCloseReason code, const std::string& reason) {
     EVLOG_info << "Closing plain websocket.";
     websocketpp::lib::error_code ec;
     this->cancel_reconnect_timer();
@@ -260,7 +260,7 @@ void WebsocketPlain::close(websocketpp::close::status::value code, const std::st
     if (ec) {
         EVLOG_error << "Error initiating close of plain websocket: " << ec.message();
         // on_close_plain won't be called here so we have to call the closed_callback manually
-        this->closed_callback(websocketpp::close::status::abnormal_close);
+        this->closed_callback(WebsocketCloseReason::AbnormalClose);
     } else {
         EVLOG_info << "Closed plain websocket successfully.";
     }

lib/ocpp/common/websocket/websocket_tls.cpp

@@ -154,7 +154,7 @@ bool WebsocketTLS::connect() {
         if (this->m_is_connected) {
             try {
                 EVLOG_info << "Closing websocket connection before reconnecting";
-                this->wss_client.close(this->handle, websocketpp::close::status::normal, "");
+                this->wss_client.close(this->handle, WebsocketCloseReason::Normal, "");
             } catch (std::exception& e) {
                 EVLOG_error << "Error on TLS close: " << e.what();
             }
@@ -202,7 +202,7 @@ void WebsocketTLS::reconnect(std::error_code reason, long delay) {
         if (this->m_is_connected) {
             try {
                 EVLOG_info << "Closing websocket connection before reconnecting";
-                this->wss_client.close(this->handle, websocketpp::close::status::normal, "");
+                this->wss_client.close(this->handle, WebsocketCloseReason::Normal, "");
             } catch (std::exception& e) {
                 EVLOG_error << "Error on plain close: " << e.what();
             }
@@ -220,7 +220,7 @@ void WebsocketTLS::reconnect(std::error_code reason, long delay) {
     // TODO(kai): complete error handling, especially making sure that a reconnect is only attempted in reasonable
     // circumstances
     switch (reason.value()) {
-    case websocketpp::close::status::force_tcp_drop:
+    case WebsocketCloseReason::ForceTcpDrop:
         /* code */
         break;
 
@@ -407,7 +407,7 @@ void WebsocketTLS::on_close_tls(tls_client* c, websocketpp::connection_hdl hdl)
                << websocketpp::close::status::get_string(con->get_remote_close_code())
                << "), reason: " << con->get_remote_close_reason();
     // dont reconnect on normal close
-    if (con->get_remote_close_code() != websocketpp::close::status::normal) {
+    if (con->get_remote_close_code() != WebsocketCloseReason::Normal) {
         this->reconnect(error_code, this->get_reconnect_interval());
     } else {
         this->closed_callback(con->get_remote_close_code());
@@ -431,11 +431,11 @@ void WebsocketTLS::on_fail_tls(tls_client* c, websocketpp::connection_hdl hdl) {
         this->connection_attempts <= this->connection_options.max_connection_attempts) {
         this->reconnect(ec, this->get_reconnect_interval());
     } else {
-        this->close(websocketpp::close::status::normal, "Connection failed");
+        this->close(WebsocketCloseReason::Normal, "Connection failed");
     }
 }
 
-void WebsocketTLS::close(websocketpp::close::status::value code, const std::string& reason) {
+void WebsocketTLS::close(WebsocketCloseReason code, const std::string& reason) {
 
     EVLOG_info << "Closing TLS websocket.";
 
@@ -448,7 +448,7 @@ void WebsocketTLS::close(websocketpp::close::status::value code, const std::stri
     if (ec) {
         EVLOG_error << "Error initiating close of TLS websocket: " << ec.message();
         // on_close_tls wont be called here so we have to call the closed_callback manually
-        this->closed_callback(websocketpp::close::status::abnormal_close);
+        this->closed_callback(WebsocketCloseReason::AbnormalClose);
     } else {
         EVLOG_info << "Closed TLS websocket successfully.";
     }

lib/ocpp/common/websocket/websocket_tls_tpm.cpp

@@ -509,7 +509,7 @@ bool WebsocketTlsTPM::connect() {
         // close connection before reconnecting
         if (this->m_is_connected) {
             EVLOG_info << "Closing websocket connection before reconnecting";
-            this->close(websocketpp::close::status::abnormal_close, "Reconnect");
+            this->close(WebsocketCloseReason::AbnormalClose, "Reconnect");
         }
 
         {
@@ -535,7 +535,7 @@ void WebsocketTlsTPM::reconnect(std::error_code reason, long delay) {
     std::lock_guard<std::mutex> lk(this->reconnect_mutex);
     if (this->m_is_connected) {
         EVLOG_info << "Closing websocket connection before reconnecting";
-        this->close(websocketpp::close::status::abnormal_close, "Reconnect");
+        this->close(WebsocketCloseReason::AbnormalClose, "Reconnect");
     }
 
     if (!this->reconnect_timer_tpm) {
@@ -550,7 +550,7 @@ void WebsocketTlsTPM::reconnect(std::error_code reason, long delay) {
     }
 }
 
-void WebsocketTlsTPM::close(websocketpp::close::status::value code, const std::string& reason) {
+void WebsocketTlsTPM::close(WebsocketCloseReason code, const std::string& reason) {
     EVLOG_info << "Closing TLS TPM websocket with reason: " << reason;
 
     {
@@ -572,7 +572,7 @@ void WebsocketTlsTPM::close(websocketpp::close::status::value code, const std::s
     }
 
     this->m_is_connected = false;
-    this->closed_callback(websocketpp::close::status::normal);
+    this->closed_callback(WebsocketCloseReason::Normal);
 }
 
 void WebsocketTlsTPM::on_conn_connected() {
@@ -593,7 +593,7 @@ void WebsocketTlsTPM::on_conn_close() {
     this->disconnected_callback();
     this->cancel_reconnect_timer();
 
-    this->closed_callback(websocketpp::close::status::normal);
+    this->closed_callback(WebsocketCloseReason::Normal);
 }
 
 void WebsocketTlsTPM::on_conn_fail() {
@@ -612,7 +612,7 @@ void WebsocketTlsTPM::on_conn_fail() {
         this->reconnect(std::error_code(), this->get_reconnect_interval());
     } else {
         EVLOG_info << "Closed TLS websocket, reconnect attempts exhausted";
-        this->close(websocketpp::close::status::normal, "Connection failed");
+        this->close(WebsocketCloseReason::Normal, "Connection failed");
     }
 }