Merge pull request #181 from c-jimenez/release/v1.4.2

c-jimenez · web-flow · commit 54095e36adaf · 2024-02-09T12:19:42.000+01:00
Release/v1.4.2
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -5,7 +5,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 project(OpenOCPP DESCRIPTION "Open Source C++ implementation of the OCPP 1.6 protocol"
-                 VERSION 1.4.1
+                 VERSION 1.4.2
 )
 
 # Definitions for Version.h file
diff --git a/examples/common/DefaultChargePointEventsHandler.cpp b/examples/common/DefaultChargePointEventsHandler.cpp
@@ -168,24 +168,16 @@ bool DefaultChargePointEventsHandler::remoteStartTransactionRequested(unsigned i
 {
     bool ret = false;
     cout << "Remote start transaction : " << connector_id << " - " << id_tag << endl;
-    if (connector_id != 0)
+
+    if(connector_id > m_config.ocppConfig().numberOfConnectors() || connector_id == 0)
     {
-        m_remote_start_pending[connector_id - 1u] = true;
-        m_remote_start_id_tag[connector_id - 1u]  = id_tag;
-        ret                                       = true;
+        ret=false;
     }
     else
     {
-        for (size_t i = 1; i <= m_config.ocppConfig().numberOfConnectors(); i++)
-        {
-            if (m_chargepoint->getConnectorStatus(i) < ChargePointStatus::Charging)
-            {
-                m_remote_start_pending[i - 1u] = true;
-                m_remote_start_id_tag[i - 1u]  = id_tag;
-                ret                            = true;
-                break;
-            }
-        }
+        m_remote_start_pending[connector_id - 1u] = true;
+        m_remote_start_id_tag[connector_id - 1u]  = id_tag;
+        ret=true;
     }
     return ret;
 }
diff --git a/examples/common/config/OcppConfig.cpp b/examples/common/config/OcppConfig.cpp
@@ -207,8 +207,8 @@ ocpp::types::ConfigurationStatus OcppConfig::setConfiguration(const std::string&
                 }
             }
 
-            if (ret != ConfigurationStatus::Rejected)
-            {
+             if (ret != ConfigurationStatus::Rejected)
+             {
                 if ((it->second & PARAM_OCPP) != 0)
                 {
                     m_config.set(OCPP_PARAMS, key, value);
@@ -225,7 +225,7 @@ ocpp::types::ConfigurationStatus OcppConfig::setConfiguration(const std::string&
                 {
                     ret = ConfigurationStatus::Accepted;
                 }
-            }
+             }
         }
         else
         {
diff --git a/src/chargepoint/reservation/ReservationManager.cpp b/src/chargepoint/reservation/ReservationManager.cpp
@@ -102,7 +102,7 @@ ocpp::types::AuthorizationStatus ReservationManager::isTransactionAllowed(unsign
     if (connector)
     {
         // Check if connector is reserved
-        if (connector->status == ChargePointStatus::Reserved)
+        if (!connector->reservation_id_tag.empty())
         {
             // Check if id tag match
             if (id_tag == connector->reservation_id_tag)
@@ -130,7 +130,7 @@ ocpp::types::AuthorizationStatus ReservationManager::isTransactionAllowed(unsign
             {
                 // Check if connector 0 is reserved
                 Connector& charge_point = m_connectors.getChargePointConnector();
-                if (charge_point.status == ChargePointStatus::Reserved)
+                if (!charge_point.reservation_id_tag.empty())
                 {
                     // Ensure that the module functions properly even when the gun is inserted first by the user.
                     if (m_connectors.getConnector(connector_id)->status == ChargePointStatus::Preparing)
@@ -234,6 +234,7 @@ bool ReservationManager::handleMessage(const ocpp::messages::ReserveNowReq& requ
                             m_status_manager.updateConnectorStatus(connector->id, ChargePointStatus::Reserved);
                             m_events_handler.reservationStarted(connector->id);
                         });
+
                     break;
                 }
 
@@ -293,7 +294,7 @@ bool ReservationManager::handleMessage(const ocpp::messages::CancelReservationRe
     response.status = CancelReservationStatus::Rejected;
     for (const Connector* connector : m_connectors.getConnectors())
     {
-        if ((connector->status == ChargePointStatus::Reserved) && (connector->reservation_id == request.reservationId))
+        if ((!connector->reservation_id_tag.empty()) && (connector->reservation_id == request.reservationId))
         {
             // Cancel reservation
             m_worker_pool.run<void>([this, connector_id = connector->id] { endReservation(connector_id, true); });
@@ -316,7 +317,7 @@ void ReservationManager::checkExpiries()
     // Check reservations
     for (const Connector* connector : m_connectors.getConnectors())
     {
-        if ((connector->status == ChargePointStatus::Reserved) && (connector->reservation_expiry_date <= now))
+        if ((!connector->reservation_id_tag.empty()) && (connector->reservation_expiry_date <= now))
         {
             // End reservation
             m_worker_pool.run<void>(std::bind(&ReservationManager::endReservation, this, connector->id, false));
diff --git a/src/chargepoint/status/StatusManager.cpp b/src/chargepoint/status/StatusManager.cpp
@@ -113,7 +113,7 @@ void StatusManager::updateConnectionStatus(bool is_connected)
             }
 
             // Restart heartbeat process
-            m_heartbeat_timer.start(m_heartbeat_timer.getInterval());
+            m_heartbeat_timer.start(m_ocpp_config.heartbeatInterval());
         }
     }
     else
@@ -144,24 +144,22 @@ bool StatusManager::updateConnectorStatus(unsigned int                      conn
     Connector* connector = m_connectors.getConnector(connector_id);
     if (connector)
     {
+        std::lock_guard<std::mutex> lock(connector->mutex);
+
         // Check if status has changed
         if (connector->status != status)
         {
-            {
-                std::lock_guard<std::mutex> lock(connector->mutex);
-
-                // Save new status
-                connector->status           = status;
-                connector->status_timestamp = DateTime::now();
-                connector->error_code       = error_code;
-                connector->info             = info;
-                connector->vendor_id        = vendor_id;
-                connector->vendor_error     = vendor_error;
-                m_connectors.saveConnector(connector->id);
-            }
-
             LOG_INFO << "Connector " << connector_id << " : " << ChargePointStatusHelper.toString(status);
 
+            // Save new status
+            connector->status           = status;
+            connector->status_timestamp = DateTime::now();
+            connector->error_code       = error_code;
+            connector->info             = info;
+            connector->vendor_id        = vendor_id;
+            connector->vendor_error     = vendor_error;
+            m_connectors.saveConnector(connector->id);
+
             // Check registration status
             if (m_registration_status == RegistrationStatus::Accepted)
             {
@@ -170,7 +168,7 @@ bool StatusManager::updateConnectorStatus(unsigned int                      conn
                 if (duration == std::chrono::seconds(0))
                 {
                     // Notify now
-                    statusNotificationProcess(connector_id);
+                    m_worker_pool.run<void>(std::bind(&StatusManager::statusNotificationProcess, this, connector_id));
                 }
                 else
                 {
@@ -197,7 +195,7 @@ void StatusManager::resetHeartBeatTimer()
 {
     if (m_heartbeat_timer.isStarted())
     {
-        m_heartbeat_timer.restart(m_heartbeat_timer.getInterval());
+        m_heartbeat_timer.restart(m_ocpp_config.heartbeatInterval());
     }
 }
 
diff --git a/src/chargepoint/transaction/TransactionManager.cpp b/src/chargepoint/transaction/TransactionManager.cpp
@@ -98,7 +98,7 @@ ocpp::types::AuthorizationStatus TransactionManager::startTransaction(unsigned i
                 start_transaction_req.timestamp  = DateTime::now();
 
                 // Check reservations
-                if (connector->status == ChargePointStatus::Reserved)
+                if (!connector->reservation_id_tag.empty())
                 {
                     // Fill reservation id
                     start_transaction_req.reservationId = connector->reservation_id;
@@ -112,7 +112,7 @@ ocpp::types::AuthorizationStatus TransactionManager::startTransaction(unsigned i
                     if (m_ocpp_config.reserveConnectorZeroSupported())
                     {
                         Connector& charge_point = m_connectors.getChargePointConnector();
-                        if (charge_point.status == ChargePointStatus::Reserved)
+                        if (!charge_point.reservation_id_tag.empty())
                         {
                             // Check if this transaction can be used for the charge point reservation
                             if (m_reservation_manager.isTransactionAllowed(Connectors::CONNECTOR_ID_CHARGE_POINT, id_tag) ==
diff --git a/src/tools/x509/Certificate.cpp b/src/tools/x509/Certificate.cpp
@@ -88,6 +88,7 @@ Certificate::Certificate(const Certificate& copy)
       m_validity_to(copy.m_validity_to),
       m_issuer(copy.m_issuer),
       m_issuer_string(copy.m_issuer_string),
+      m_issuer_der(copy.m_issuer_der),
       m_is_self_signed(copy.m_is_self_signed)
 {
     // Duplicate OpenSSL object
diff --git a/src/websockets/Url.cpp b/src/websockets/Url.cpp
@@ -18,7 +18,9 @@ along with OpenOCPP. If not, see <http://www.gnu.org/licenses/>.
 
 #include "Url.h"
 
+#include <iomanip>
 #include <regex>
+#include <sstream>
 
 namespace ocpp
 {
@@ -46,9 +48,9 @@ Url::Url(const std::string& url)
 
         // Convert path
         m_path = match[10].str();
-        if (m_path.empty())
+        if (!m_path.empty())
         {
-            m_path = "/";
+            m_path = encode(m_path);
         }
 
         // Convert port
@@ -68,11 +70,59 @@ Url::Url(const std::string& url)
                 m_is_valid = false;
             }
         }
+
+        // Rebuild URL
+        if (m_is_valid)
+        {
+            std::stringstream encoded_url;
+            encoded_url << m_protocol << "://";
+            if (!m_username.empty() || !m_password.empty())
+            {
+                encoded_url << m_username;
+                if (!m_password.empty())
+                {
+                    encoded_url << ":" << m_password;
+                }
+                encoded_url << "@";
+            }
+            encoded_url << m_address;
+            if (m_port != 0)
+            {
+                encoded_url << ":" << m_port;
+            }
+            encoded_url << m_path;
+            m_url = encoded_url.str();
+        }
     }
 }
 
 /** @brief Destructor */
 Url::~Url() { }
 
+/** @brief Encode an URL */
+std::string Url::encode(const std::string& url) const
+{
+    std::stringstream encoded_url;
+    encoded_url << std::hex;
+
+    for (const auto& c : url)
+    {
+        // Safe characters
+        if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9')) || (c == '/'))
+        {
+            // No encoding
+            encoded_url << c;
+        }
+        else
+        {
+            // Percent encoding
+            encoded_url << '%';
+            encoded_url << std::setw(2) << std::setfill('0') << static_cast<int>(c);
+        }
+    }
+
+    return encoded_url.str();
+}
+
 } // namespace websockets
 } // namespace ocpp
diff --git a/src/websockets/Url.h b/src/websockets/Url.h
@@ -113,6 +113,9 @@ class Url
     unsigned int m_port;
     /** @brief Path part of the URL */
     std::string m_path;
+
+    /** @brief Encode an URL */
+    std::string encode(const std::string& url) const;
 };
 
 } // namespace websockets
diff --git a/src/websockets/libwebsockets/LibWebsocketClient.cpp b/src/websockets/libwebsockets/LibWebsocketClient.cpp
@@ -98,8 +98,10 @@ bool LibWebsocketClient::connect(const std::string&        url,
             info.port         = CONTEXT_PORT_NO_LISTEN;
             info.protocols    = protocols;
             info.timeout_secs = static_cast<unsigned int>(std::chrono::duration_cast<std::chrono::seconds>(connect_timeout).count());
-            info.log_cx       = &m_logs_context;
-            m_credentials     = credentials;
+            info.connect_timeout_secs =
+                static_cast<unsigned int>(std::chrono::duration_cast<std::chrono::seconds>(connect_timeout).count());
+            info.log_cx   = &m_logs_context;
+            m_credentials = credentials;
             if (m_url.protocol() == "wss")
             {
                 if (!m_credentials.tls12_cipher_list.empty())
@@ -505,6 +507,12 @@ int LibWebsocketClient::eventCallback(struct lws* wsi, enum lws_callback_reasons
             {
                 retry = true;
             }
+
+            SendMsg* msg;
+            while (client->m_send_msgs.pop(msg, 0))
+            {
+                delete msg;
+            }
             break;
 
         default:
diff --git a/src/websockets/libwebsockets/LibWebsocketClientPool.cpp b/src/websockets/libwebsockets/LibWebsocketClientPool.cpp
@@ -144,7 +144,7 @@ void LibWebsocketClientPool::process()
 
     // Dummy vhost to handle context related events
     struct lws_protocols             protocols[] = {{"LibWebsocketClientPool", &LibWebsocketClientPool::eventCallback, 0, 0, 0, this, 0},
-                                        LWS_PROTOCOL_LIST_TERM};
+                                                    LWS_PROTOCOL_LIST_TERM};
     struct lws_context_creation_info vhost_info;
     memset(&vhost_info, 0, sizeof(vhost_info));
     vhost_info.protocols = protocols;
@@ -443,11 +443,12 @@ void LibWebsocketClientPool::Client::connectCallback(struct lws_sorted_usec_list
             // Fill vhost information
             struct lws_context_creation_info vhost_info;
             memset(&vhost_info, 0, sizeof(vhost_info));
-            vhost_info.options      = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
-            vhost_info.port         = CONTEXT_PORT_NO_LISTEN;
-            vhost_info.timeout_secs = client->m_connect_timeout;
-            vhost_info.protocols    = protocols;
-            vhost_info.log_cx       = &pool->m_logs_context;
+            vhost_info.options              = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
+            vhost_info.port                 = CONTEXT_PORT_NO_LISTEN;
+            vhost_info.timeout_secs         = client->m_connect_timeout;
+            vhost_info.connect_timeout_secs = client->m_connect_timeout;
+            vhost_info.protocols            = protocols;
+            vhost_info.log_cx               = &pool->m_logs_context;
             if (client->m_url.protocol() == "wss")
             {
                 if (!client->m_credentials.tls12_cipher_list.empty())
@@ -686,6 +687,12 @@ int LibWebsocketClientPool::Client::eventCallback(
             {
                 retry = true;
             }
+
+            SendMsg* msg;
+            while (client->m_send_msgs.pop(msg, 0))
+            {
+                delete msg;
+            }
             break;
 
         default:
diff --git a/tests/websockets/test_websockets_url.cpp b/tests/websockets/test_websockets_url.cpp

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`cmake_minimum_required(VERSION 3.13)`
`6`	`6`
`7`	`7`	`project(OpenOCPP DESCRIPTION "Open Source C++ implementation of the OCPP 1.6 protocol"`
`8`		`- VERSION 1.4.1`
	`8`	`+ VERSION 1.4.2`
`9`	`9`	`)`
`10`	`10`
`11`	`11`	`# Definitions for Version.h file`
Original file line number	Diff line number	Diff line change
`@@ -168,24 +168,16 @@ bool DefaultChargePointEventsHandler::remoteStartTransactionRequested(unsigned i`
`168`	`168`	`{`
`169`	`169`	`bool ret = false;`
`170`	`170`	`cout << "Remote start transaction : " << connector_id << " - " << id_tag << endl;`
`171`		`- if (connector_id != 0)`
	`171`	`+`
	`172`	`+ if(connector_id > m_config.ocppConfig().numberOfConnectors() \|\| connector_id == 0)`
`172`	`173`	`{`
`173`		`- m_remote_start_pending[connector_id - 1u] = true;`
`174`		`- m_remote_start_id_tag[connector_id - 1u] = id_tag;`
`175`		`- ret = true;`
	`174`	`+ ret=false;`
`176`	`175`	`}`
`177`	`176`	`else`
`178`	`177`	`{`
`179`		`- for (size_t i = 1; i <= m_config.ocppConfig().numberOfConnectors(); i++)`
`180`		`- {`
`181`		`- if (m_chargepoint->getConnectorStatus(i) < ChargePointStatus::Charging)`
`182`		`- {`
`183`		`- m_remote_start_pending[i - 1u] = true;`
`184`		`- m_remote_start_id_tag[i - 1u] = id_tag;`
`185`		`- ret = true;`
`186`		`- break;`
`187`		`- }`
`188`		`- }`
	`178`	`+ m_remote_start_pending[connector_id - 1u] = true;`
	`179`	`+ m_remote_start_id_tag[connector_id - 1u] = id_tag;`
	`180`	`+ ret=true;`
`189`	`181`	`}`
`190`	`182`	`return ret;`
`191`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -207,8 +207,8 @@ ocpp::types::ConfigurationStatus OcppConfig::setConfiguration(const std::string&`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`
`210`		`- if (ret != ConfigurationStatus::Rejected)`
`211`		`- {`
	`210`	`+ if (ret != ConfigurationStatus::Rejected)`
	`211`	`+ {`
`212`	`212`	`if ((it->second & PARAM_OCPP) != 0)`
`213`	`213`	`{`
`214`	`214`	`m_config.set(OCPP_PARAMS, key, value);`
`@@ -225,7 +225,7 @@ ocpp::types::ConfigurationStatus OcppConfig::setConfiguration(const std::string&`
`225`	`225`	`{`
`226`	`226`	`ret = ConfigurationStatus::Accepted;`
`227`	`227`	`}`
`228`		`- }`
	`228`	`+ }`
`229`	`229`	`}`
`230`	`230`	`else`
`231`	`231`	`{`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ ocpp::types::AuthorizationStatus ReservationManager::isTransactionAllowed(unsign`
`102`	`102`	`if (connector)`
`103`	`103`	`{`
`104`	`104`	`// Check if connector is reserved`
`105`		`- if (connector->status == ChargePointStatus::Reserved)`
	`105`	`+ if (!connector->reservation_id_tag.empty())`
`106`	`106`	`{`
`107`	`107`	`// Check if id tag match`
`108`	`108`	`if (id_tag == connector->reservation_id_tag)`
`@@ -130,7 +130,7 @@ ocpp::types::AuthorizationStatus ReservationManager::isTransactionAllowed(unsign`
`130`	`130`	`{`
`131`	`131`	`// Check if connector 0 is reserved`
`132`	`132`	`Connector& charge_point = m_connectors.getChargePointConnector();`
`133`		`- if (charge_point.status == ChargePointStatus::Reserved)`
	`133`	`+ if (!charge_point.reservation_id_tag.empty())`
`134`	`134`	`{`
`135`	`135`	`// Ensure that the module functions properly even when the gun is inserted first by the user.`
`136`	`136`	`if (m_connectors.getConnector(connector_id)->status == ChargePointStatus::Preparing)`
`@@ -234,6 +234,7 @@ bool ReservationManager::handleMessage(const ocpp::messages::ReserveNowReq& requ`
`234`	`234`	`m_status_manager.updateConnectorStatus(connector->id, ChargePointStatus::Reserved);`
`235`	`235`	`m_events_handler.reservationStarted(connector->id);`
`236`	`236`	`});`
	`237`	`+`
`237`	`238`	`break;`
`238`	`239`	`}`
`239`	`240`
`@@ -293,7 +294,7 @@ bool ReservationManager::handleMessage(const ocpp::messages::CancelReservationRe`
`293`	`294`	`response.status = CancelReservationStatus::Rejected;`
`294`	`295`	`for (const Connector* connector : m_connectors.getConnectors())`
`295`	`296`	`{`
`296`		`- if ((connector->status == ChargePointStatus::Reserved) && (connector->reservation_id == request.reservationId))`
	`297`	`+ if ((!connector->reservation_id_tag.empty()) && (connector->reservation_id == request.reservationId))`
`297`	`298`	`{`
`298`	`299`	`// Cancel reservation`
`299`	`300`	`m_worker_pool.run<void>([this, connector_id = connector->id] { endReservation(connector_id, true); });`
`@@ -316,7 +317,7 @@ void ReservationManager::checkExpiries()`
`316`	`317`	`// Check reservations`
`317`	`318`	`for (const Connector* connector : m_connectors.getConnectors())`
`318`	`319`	`{`
`319`		`- if ((connector->status == ChargePointStatus::Reserved) && (connector->reservation_expiry_date <= now))`
	`320`	`+ if ((!connector->reservation_id_tag.empty()) && (connector->reservation_expiry_date <= now))`
`320`	`321`	`{`
`321`	`322`	`// End reservation`
`322`	`323`	`m_worker_pool.run<void>(std::bind(&ReservationManager::endReservation, this, connector->id, false));`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ void StatusManager::updateConnectionStatus(bool is_connected)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`// Restart heartbeat process`
`116`		`- m_heartbeat_timer.start(m_heartbeat_timer.getInterval());`
	`116`	`+ m_heartbeat_timer.start(m_ocpp_config.heartbeatInterval());`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`else`
`@@ -144,24 +144,22 @@ bool StatusManager::updateConnectorStatus(unsigned int conn`
`144`	`144`	`Connector* connector = m_connectors.getConnector(connector_id);`
`145`	`145`	`if (connector)`
`146`	`146`	`{`
	`147`	`+ std::lock_guard<std::mutex> lock(connector->mutex);`
	`148`	`+`
`147`	`149`	`// Check if status has changed`
`148`	`150`	`if (connector->status != status)`
`149`	`151`	`{`
`150`		`- {`
`151`		`- std::lock_guard<std::mutex> lock(connector->mutex);`
`152`		`-`
`153`		`- // Save new status`
`154`		`- connector->status = status;`
`155`		`- connector->status_timestamp = DateTime::now();`
`156`		`- connector->error_code = error_code;`
`157`		`- connector->info = info;`
`158`		`- connector->vendor_id = vendor_id;`
`159`		`- connector->vendor_error = vendor_error;`
`160`		`- m_connectors.saveConnector(connector->id);`
`161`		`- }`
`162`		`-`
`163`	`152`	`LOG_INFO << "Connector " << connector_id << " : " << ChargePointStatusHelper.toString(status);`
`164`	`153`
	`154`	`+ // Save new status`
	`155`	`+ connector->status = status;`
	`156`	`+ connector->status_timestamp = DateTime::now();`
	`157`	`+ connector->error_code = error_code;`
	`158`	`+ connector->info = info;`
	`159`	`+ connector->vendor_id = vendor_id;`
	`160`	`+ connector->vendor_error = vendor_error;`
	`161`	`+ m_connectors.saveConnector(connector->id);`
	`162`	`+`
`165`	`163`	`// Check registration status`
`166`	`164`	`if (m_registration_status == RegistrationStatus::Accepted)`
`167`	`165`	`{`
`@@ -170,7 +168,7 @@ bool StatusManager::updateConnectorStatus(unsigned int conn`
`170`	`168`	`if (duration == std::chrono::seconds(0))`
`171`	`169`	`{`
`172`	`170`	`// Notify now`
`173`		`- statusNotificationProcess(connector_id);`
	`171`	`+ m_worker_pool.run<void>(std::bind(&StatusManager::statusNotificationProcess, this, connector_id));`
`174`	`172`	`}`
`175`	`173`	`else`
`176`	`174`	`{`
`@@ -197,7 +195,7 @@ void StatusManager::resetHeartBeatTimer()`
`197`	`195`	`{`
`198`	`196`	`if (m_heartbeat_timer.isStarted())`
`199`	`197`	`{`
`200`		`- m_heartbeat_timer.restart(m_heartbeat_timer.getInterval());`
	`198`	`+ m_heartbeat_timer.restart(m_ocpp_config.heartbeatInterval());`
`201`	`199`	`}`
`202`	`200`	`}`
`203`	`201`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ ocpp::types::AuthorizationStatus TransactionManager::startTransaction(unsigned i`
`98`	`98`	`start_transaction_req.timestamp = DateTime::now();`
`99`	`99`
`100`	`100`	`// Check reservations`
`101`		`- if (connector->status == ChargePointStatus::Reserved)`
	`101`	`+ if (!connector->reservation_id_tag.empty())`
`102`	`102`	`{`
`103`	`103`	`// Fill reservation id`
`104`	`104`	`start_transaction_req.reservationId = connector->reservation_id;`
`@@ -112,7 +112,7 @@ ocpp::types::AuthorizationStatus TransactionManager::startTransaction(unsigned i`
`112`	`112`	`if (m_ocpp_config.reserveConnectorZeroSupported())`
`113`	`113`	`{`
`114`	`114`	`Connector& charge_point = m_connectors.getChargePointConnector();`
`115`		`- if (charge_point.status == ChargePointStatus::Reserved)`
	`115`	`+ if (!charge_point.reservation_id_tag.empty())`
`116`	`116`	`{`
`117`	`117`	`// Check if this transaction can be used for the charge point reservation`
`118`	`118`	`if (m_reservation_manager.isTransactionAllowed(Connectors::CONNECTOR_ID_CHARGE_POINT, id_tag) ==`
Original file line number	Diff line number	Diff line change
`@@ -88,6 +88,7 @@ Certificate::Certificate(const Certificate& copy)`
`88`	`88`	`m_validity_to(copy.m_validity_to),`
`89`	`89`	`m_issuer(copy.m_issuer),`
`90`	`90`	`m_issuer_string(copy.m_issuer_string),`
	`91`	`+ m_issuer_der(copy.m_issuer_der),`
`91`	`92`	`m_is_self_signed(copy.m_is_self_signed)`
`92`	`93`	`{`
`93`	`94`	`// Duplicate OpenSSL object`