websocket_base.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_WEBSOCKET_BASE_HPP
#define OCPP_WEBSOCKET_BASE_HPP
 
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
 
#include <everest/timer.hpp>
 
#include <ocpp/common/types.hpp>
#include <ocpp/common/websocket/websocket_uri.hpp>
 
namespace ocpp {
 
struct WebsocketConnectionOptions {
    std::vector<OcppProtocolVersion> ocpp_versions; // List of allowed protocols ordered by preference
    Uri csms_uri;                                   // the URI of the CSMS
    int security_profile;                           // FIXME: change type to `SecurityProfile`
    std::optional<std::string> authorization_key;
    int retry_backoff_random_range_s;
    int retry_backoff_repeat_times;
    int retry_backoff_wait_minimum_s;
    int max_connection_attempts;
    std::string supported_ciphers_12;
    std::string supported_ciphers_13;
    int ping_interval_s;
    std::string ping_payload;
    int pong_timeout_s;
    bool use_ssl_default_verify_paths;
    std::optional<bool> additional_root_certificate_check;
    std::optional<std::string> hostName;
    bool verify_csms_common_name;
    bool use_tpm_tls;
    bool verify_csms_allow_wildcards;
    std::optional<std::string> iface; // Optional interface where the socket is created. Only usable for libwebsocket
    bool enable_tls_keylog = false;   
    std::optional<std::filesystem::path> keylog_file; 
};
 
class WebsocketBase {
protected:
    std::atomic_bool m_is_connected;
    WebsocketConnectionOptions connection_options;
    std::function<void(OcppProtocolVersion protocol)> connected_callback;
    std::function<void()> disconnected_callback;
    std::function<void(const WebsocketCloseReason reason)> stopped_connecting_callback;
    std::function<void(const std::string& message)> message_callback;
    std::function<void(ConnectionFailedReason)> connection_failed_callback;
    std::shared_ptr<boost::asio::steady_timer> reconnect_timer;
    std::unique_ptr<Everest::SteadyTimer> ping_timer;
    std::mutex reconnect_mutex;
    std::mutex connection_mutex;
    std::atomic_int reconnect_backoff_ms;
    std::atomic_int connection_attempts;
    std::atomic_bool shutting_down;
    std::atomic_bool reconnecting;
 
    bool initialized();
 
    std::optional<std::string> getAuthorizationHeader();
 
    void log_on_fail(const std::error_code& ec, const boost::system::error_code& transport_ec, const int http_status);
 
    long get_reconnect_interval();
 
    // \brief cancels the reconnect timer
    void cancel_reconnect_timer();
 
    virtual void ping() = 0;
 
    void on_pong_timeout(std::string msg);
 
public:
    explicit WebsocketBase();
    virtual ~WebsocketBase();
 
    virtual bool start_connecting() = 0;
 
    virtual void set_connection_options(const WebsocketConnectionOptions& connection_options) = 0;
    void set_connection_options_base(const WebsocketConnectionOptions& connection_options);
 
    virtual void reconnect(long delay) = 0;
 
    void disconnect(const WebsocketCloseReason code);
 
    bool is_connected();
 
    virtual void close(const WebsocketCloseReason code, const std::string& reason) = 0;
 
    void register_connected_callback(const std::function<void(OcppProtocolVersion protocol)>& callback);
 
    void register_disconnected_callback(const std::function<void()>& callback);
 
    void register_stopped_connecting_callback(const std::function<void(const WebsocketCloseReason reason)>& callback);
 
    void register_message_callback(const std::function<void(const std::string& message)>& callback);
 
    void register_connection_failed_callback(const std::function<void(ConnectionFailedReason)>& callback);
 
    virtual bool send(const std::string& message) = 0;
 
    void set_websocket_ping_interval(int32_t interval_s);
 
    void set_authorization_key(const std::string& authorization_key);
};
 
} // namespace ocpp
#endif // OCPP_WEBSOCKET_BASE_HPP