Add AuthorizationSetup to EV side state machine, including a feedback mechanism to report EVSE parameters to the EV.

include/iso15118/ev/d20/context.hpp

@@ -9,6 +9,7 @@
 #include <iso15118/message/variant.hpp>
 
 #include <iso15118/ev/d20/session.hpp>
+#include <iso15118/ev/session/feedback.hpp>
 #include <iso15118/io/sha_hash.hpp>
 
 namespace iso15118::ev::d20 {
@@ -56,7 +57,7 @@ class Session;
 
 class Context {
 public:
-    Context(MessageExchange&);
+    Context(session::feedback::Callbacks, MessageExchange&);
 
     template <typename StateType, typename... Args> BasePointerType create_state(Args&&... args) {
         return std::make_unique<StateType>(*this, std::forward<Args>(args)...);
@@ -105,6 +106,11 @@ class Context {
         return session;
     }
 
+    // Contains the EVSE received data
+    EVSESessionInfo evse_session_info;
+
+    const iso15118::ev::d20::session::Feedback feedback;
+
 private:
     MessageExchange& message_exchange;
 

include/iso15118/ev/d20/evse_session_info.hpp

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2025 Pionix GmbH and Contributors to EVerest
+#pragma once
+
+#include <iso15118/message/common_types.hpp>
+
+namespace iso15118::ev::d20 {
+
+// Holds information reported by the EVSE that could be different between sessions
+struct EVSESessionInfo {
+    std::vector<message_20::datatypes::Authorization> auth_services{};
+    bool certificate_installation_service{false};
+    std::optional<std::vector<message_20::datatypes::Name>> supported_providers{std::nullopt};
+    message_20::datatypes::GenChallenge gen_challenge{std::array<uint8_t, 16>{}}; // 16 bytes
+};
+
+} // namespace iso15118::ev::d20

include/iso15118/ev/d20/session.hpp

@@ -4,6 +4,7 @@
 
 #include <array>
 #include <cstdint>
+#include <iso15118/io/sha_hash.hpp>
 
 namespace iso15118::ev::d20 {
 

include/iso15118/ev/d20/state/authorization.hpp

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2025 Pionix GmbH and Contributors to EVerest
+#pragma once
+
+#include "../states.hpp"
+
+namespace iso15118::ev::d20::state {
+
+struct Authorization : public StateBase {
+public:
+    Authorization(Context& ctx) : StateBase(ctx, StateID::Authorization) {
+    }
+
+    void enter() final;
+
+    Result feed(Event) final;
+};
+
+} // namespace iso15118::ev::d20::state

include/iso15118/ev/detail/d20/context_helper.hpp

@@ -2,8 +2,8 @@
 // Copyright 2025 Pionix GmbH and Contributors to EVerest
 #pragma once
 
-// #include <iso15118/d20/context.hpp>
-// #include <iso15118/d20/session.hpp>
+#include <iso15118/ev/d20/context.hpp>
+#include <iso15118/ev/d20/session.hpp>
 #include <iso15118/message/common_types.hpp>
 
 // Forward declaration

include/iso15118/ev/session/feedback.hpp

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2023 Pionix GmbH and Contributors to EVerest
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include <iso15118/ev/d20/evse_session_info.hpp>
+#include <iso15118/ev/d20/session.hpp>
+#include <iso15118/message/dc_charge_loop.hpp>
+#include <iso15118/message/dc_charge_parameter_discovery.hpp>
+#include <iso15118/message/schedule_exchange.hpp>
+#include <iso15118/message/service_detail.hpp>
+#include <iso15118/message/service_selection.hpp>
+#include <iso15118/message/type.hpp>
+
+namespace iso15118::ev::d20::session {
+
+namespace dt = message_20::datatypes;
+
+namespace feedback {
+
+struct Callbacks {
+    std::function<void(const EVSESessionInfo&)> evse_session_info;
+};
+
+} // namespace feedback
+
+class Feedback {
+public:
+    Feedback(feedback::Callbacks);
+
+    void evse_session_info(const EVSESessionInfo&) const;
+
+private:
+    feedback::Callbacks callbacks;
+};
+
+} // namespace iso15118::ev::d20::session

src/iso15118/CMakeLists.txt

@@ -16,7 +16,9 @@ target_sources(iso15118
         ev/d20/context_helper.cpp
         ev/d20/state/session_setup.cpp
         ev/d20/state/authorization_setup.cpp
+        ev/d20/state/authorization.cpp
         ev/d20/state/dc_charge_parameter_discovery.cpp
+        ev/session/feedback.cpp
 
         io/connection_plain.cpp
         io/logging.cpp

src/iso15118/ev/d20/context.cpp

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright 2025 Pionix GmbH and Contributors to EVerest
-#include <iso15118/ev/d20/context.hpp>
-
 #include <iso15118/detail/helper.hpp>
+#include <iso15118/ev/d20/context.hpp>
+#include <iso15118/ev/detail/d20/context_helper.hpp>
 
 namespace iso15118::ev::d20 {
 
@@ -28,13 +28,14 @@ std::unique_ptr<message_20::Variant> MessageExchange::pull_response() {
 
 message_20::Type MessageExchange::peek_response_type() const {
     if (not response) {
-        logf_warning("Tried to access V2G message, but there is none");
+        iso15118::logf_warning("Tried to access V2G message, but there is none");
         return message_20::Type::None;
     }
     return response->get_type();
 }
 
-Context::Context(MessageExchange& message_exchange_) : message_exchange(message_exchange_) {
+Context::Context(session::feedback::Callbacks feedback_callbacks, MessageExchange& message_exchange_) :
+    feedback(std::move(feedback_callbacks)), message_exchange(message_exchange_) {
 }
 
 std::unique_ptr<message_20::Variant> Context::pull_response() {

src/iso15118/ev/d20/state/authorization.cpp

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2025 Pionix GmbH and Contributors to EVerest
+#include <iso15118/detail/helper.hpp>
+#include <iso15118/ev/d20/state/authorization.hpp>
+#include <iso15118/ev/detail/d20/context_helper.hpp>
+#include <iso15118/message/authorization.hpp>
+
+namespace iso15118::ev::d20::state {
+
+message_20::AuthorizationRequest handle_request() {
+    // TODO(SL): Implement
+    return message_20::AuthorizationRequest();
+}
+
+void Authorization::enter() {
+    // TODO(SL): Adding logging
+}
+
+Result Authorization::feed(Event ev) {
+    if (ev != Event::V2GTP_MESSAGE) {
+        return {};
+    } else {
+        return {};
+    }
+}
+
+} // namespace iso15118::ev::d20::state

src/iso15118/ev/d20/state/authorization_setup.cpp

@@ -1,14 +1,103 @@
 // SPDX-License-Identifier: Apache-2.0
-// Copyright 2025 Pionix GmbH and Contributors to EVerest
+// Copyright 2025 Pionix GmbH, Roger Bedell and Contributors to EVerest
+#include <iso15118/detail/helper.hpp>
+#include <iso15118/ev/d20/context.hpp>
+#include <iso15118/ev/d20/state/authorization.hpp>
 #include <iso15118/ev/d20/state/authorization_setup.hpp>
+#include <iso15118/ev/detail/d20/context_helper.hpp>
+#include <iso15118/ev/session/feedback.hpp>
+#include <iso15118/message/authorization.hpp>
+#include <iso15118/message/authorization_setup.hpp>
 
 namespace iso15118::ev::d20::state {
 
+namespace {
+using ResponseCode = message_20::datatypes::ResponseCode;
+bool check_response_code(ResponseCode response_code) {
+    switch (response_code) {
+    case ResponseCode::OK:
+        return true;
+        [[fallthrough]];
+    default:
+        return false;
+    }
+}
+} // namespace
+
 void AuthorizationSetup::enter() {
+    // TODO(SL): Adding logging
 }
 
 Result AuthorizationSetup::feed([[maybe_unused]] Event ev) {
-    return {};
-}
+    if (ev != Event::V2GTP_MESSAGE) {
+        return {};
+    }
+
+    const auto variant = m_ctx.pull_response();
+
+    if (const auto res = variant->get_if<message_20::AuthorizationSetupResponse>()) {
 
+        if (not check_response_code(res->response_code)) {
+            m_ctx.stop_session(true); // Tell stack to close the tcp/tls connection
+            return {};
+        }
+
+        if (res->certificate_installation_service) {
+            // TODO(RB): Implement certificate installation service
+            logf_warning("EVSE supports certificate installation service, but this is not implemented in the EV yet.");
+            // Remember it in the context for later use
+            m_ctx.evse_session_info.certificate_installation_service = true;
+        }
+
+        // Save the offered authorization services in the session context so we can use it later and also report it to
+        // the EV.
+        m_ctx.evse_session_info.auth_services = res->authorization_services;
+
+        if (res->authorization_mode.index() == 1) { // PnC
+            const auto& pnc_auth_mode =
+                std::get<message_20::datatypes::PnC_ASResAuthorizationMode>(res->authorization_mode);
+            if (pnc_auth_mode.supported_providers.has_value()) {
+                m_ctx.evse_session_info.supported_providers = pnc_auth_mode.supported_providers.value();
+            }
+            m_ctx.evse_session_info.gen_challenge = pnc_auth_mode.gen_challenge;
+        } else {
+            // EIM selected, nothing to do here for now since authorization_mode is empty for EIM
+        }
+        // Inform the ev about the evse session information
+        m_ctx.feedback.evse_session_info(m_ctx.evse_session_info);
+
+        // Send request and transition to next state
+        message_20::AuthorizationRequest req;
+        setup_header(req.header, m_ctx.get_session());
+        // TODO(RB): Choose the authorization service based on user preference and what the evse supports
+        // For now, we just pick the first one offered by the evse
+        if (m_ctx.evse_session_info.auth_services.empty()) {
+            logf_error("No authorization services offered by the EVSE. Abort the session.");
+            m_ctx.stop_session(true); // Tell stack to close the tcp/tls connection
+            return {};
+        }
+        req.selected_authorization_service = m_ctx.evse_session_info.auth_services.front();
+        if (req.selected_authorization_service == message_20::datatypes::Authorization::EIM) {
+            req.authorization_mode = message_20::datatypes::EIM_ASReqAuthorizationMode{};
+        } else if (req.selected_authorization_service == message_20::datatypes::Authorization::PnC) {
+            // TODO(RB): Fill in the PnC authorization mode data
+            // For now, we just fill in dummy data
+            message_20::datatypes::PnC_ASReqAuthorizationMode pnc_mode;
+            pnc_mode.id = "dummy_id";                                       // TODO(RB): Replace with actual ID
+            pnc_mode.gen_challenge = m_ctx.evse_session_info.gen_challenge; // Use the challenge from the evse
+            // TODO(RB): Fill in the contract certificate chain
+            req.authorization_mode = pnc_mode;
+        } else {
+            logf_error("Unknown authorization service selected. Abort the session.");
+            m_ctx.stop_session(true); // Tell stack to close the tcp/tls connection
+            return {};
+        }
+        m_ctx.respond(req);
+        return m_ctx.create_state<Authorization>();
+    } else {
+        logf_error("expected AuthorizationSetupResponse! But code type id: %d", variant->get_type());
+        m_ctx.stop_session(true); // Tell stack to close the tcp/tls connection
+        return {};
+    }
+}
 } // namespace iso15118::ev::d20::state

src/iso15118/ev/session/feedback.cpp

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2023 Pionix GmbH and Contributors to EVerest
+#include <iso15118/ev/session/feedback.hpp>
+
+#include <iso15118/detail/helper.hpp>
+#include <iso15118/ev/d20/evse_session_info.hpp>
+namespace iso15118::ev::d20::session {
+
+Feedback::Feedback(feedback::Callbacks callbacks_) : callbacks(std::move(callbacks_)) {
+}
+
+void Feedback::evse_session_info(const d20::EVSESessionInfo& info) const {
+    call_if_available(callbacks.evse_session_info, info);
+}
+
+} // namespace iso15118::ev::d20::session

test/iso15118/ev/fsm/CMakeLists.txt

@@ -14,4 +14,5 @@ function(create_ev_fsm_test_target NAME)
     catch_discover_tests(test_ev_fsm_${NAME})
 endfunction()
 
-create_ev_fsm_test_target(session_setup)
+create_ev_fsm_test_target(session_setup)
+create_ev_fsm_test_target(authorization_setup)