doip_vehicle_identification_handler.cpp

Go to the documentation of this file.

/* Diagnostic Client library
* Copyright (C) 2024  Avijit Dey
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#include "channel/udp_channel/doip_vehicle_identification_handler.h"
 
#include "channel/udp_channel/doip_udp_channel.h"
#include "common/common_doip_types.h"
#include "common/logger.h"
#include "utility/state.h"
#include "utility/sync_timer.h"
 
namespace doip_client {
namespace channel {
namespace udp_channel {
namespace {
 
using VehiclePayloadType = std::pair<std::uint16_t, std::uint8_t>;
 
enum class VehicleIdentificationState : std::uint8_t {
  kIdle = 0U,
  kSendVehicleIdentificationReq,
  kWaitForVehicleIdentificationRes,
  kDoIPCtrlTimeout
};
 
class kIdle final : public utility::state::State<VehicleIdentificationState> {
 public:
  explicit kIdle(VehicleIdentificationState state) : State<VehicleIdentificationState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
class kSendVehicleIdentificationReq final
    : public utility::state::State<VehicleIdentificationState> {
 public:
  explicit kSendVehicleIdentificationReq(VehicleIdentificationState state)
      : State<VehicleIdentificationState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
class kWaitForVehicleIdentificationRes final
    : public utility::state::State<VehicleIdentificationState> {
 public:
  explicit kWaitForVehicleIdentificationRes(VehicleIdentificationState state)
      : State<VehicleIdentificationState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
class kDoIPCtrlTimeout final : public utility::state::State<VehicleIdentificationState> {
 public:
  explicit kDoIPCtrlTimeout(VehicleIdentificationState state)
      : State<VehicleIdentificationState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
auto CreateDoipGenericHeader(std::uint16_t payload_type, std::uint32_t payload_len) noexcept
    -> std::vector<std::uint8_t> {
  std::vector<std::uint8_t> output_buffer{};
  output_buffer.emplace_back(kDoip_ProtocolVersion);
  output_buffer.emplace_back(~(static_cast<std::uint8_t>(kDoip_ProtocolVersion)));
  output_buffer.emplace_back(static_cast<std::uint8_t>((payload_type & 0xFF00) >> 8));
  output_buffer.emplace_back(static_cast<std::uint8_t>(payload_type & 0x00FF));
  output_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0xFF000000) >> 24));
  output_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0x00FF0000) >> 16));
  output_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0x0000FF00) >> 8));
  output_buffer.emplace_back(static_cast<std::uint8_t>(payload_len & 0x000000FF));
  return output_buffer;
}
 
auto GetVehicleIdentificationPayloadType(std::uint8_t preselection_mode) noexcept
    -> VehiclePayloadType {
  std::uint16_t vehicle_identification_type{0u};
  std::uint8_t vehicle_identification_length{0u};
  switch (preselection_mode) {
    case 0U:
      vehicle_identification_type = kDoip_VehicleIdentification_ReqType;
      vehicle_identification_length = kDoip_VehicleIdentification_ReqLen;
      break;
    case 1U:
      vehicle_identification_type = kDoip_VehicleIdentificationVIN_ReqType;
      vehicle_identification_length = kDoip_VehicleIdentificationVIN_ReqLen;
      break;
    case 2U:
      vehicle_identification_type = kDoip_VehicleIdentificationEID_ReqType;
      vehicle_identification_length = kDoip_VehicleIdentificationEID_ReqLen;
      break;
    default:
      break;
  }
  return VehiclePayloadType{vehicle_identification_type, vehicle_identification_length};
}
 
}  // namespace
 
class VehicleIdentificationHandler::VehicleIdentificationHandlerImpl final {
 public:
  using VehicleIdentificationStateContext =
      utility::state::StateContext<VehicleIdentificationState>;
 
  using SyncTimer = utility::sync_timer::SyncTimer<std::chrono::steady_clock>;
 
  explicit VehicleIdentificationHandlerImpl(sockets::UdpSocketHandler &udp_socket_handler,
                                            DoipUdpChannel &channel)
      : udp_socket_handler_{udp_socket_handler},
        channel_{channel},
        state_context_{} {
    // create and add state for vehicle identification
    // kIdle
    state_context_.AddState(VehicleIdentificationState::kIdle,
                            std::make_unique<kIdle>(VehicleIdentificationState::kIdle));
    // kSendVehicleIdentificationReq
    state_context_.AddState(VehicleIdentificationState::kSendVehicleIdentificationReq,
                            std::make_unique<kSendVehicleIdentificationReq>(
                                VehicleIdentificationState::kSendVehicleIdentificationReq));
    // kWaitForVehicleIdentificationRes
    state_context_.AddState(VehicleIdentificationState::kWaitForVehicleIdentificationRes,
                            std::make_unique<kWaitForVehicleIdentificationRes>(
                                VehicleIdentificationState::kWaitForVehicleIdentificationRes));
    // kDoIPCtrlTimeout
    state_context_.AddState(
        VehicleIdentificationState::kDoIPCtrlTimeout,
        std::make_unique<kDoIPCtrlTimeout>(VehicleIdentificationState::kDoIPCtrlTimeout));
    // Transit to idle state
    state_context_.TransitionTo(VehicleIdentificationState::kIdle);
  }
 
  auto GetStateContext() noexcept -> VehicleIdentificationStateContext & { return state_context_; }
 
  auto GetSocketHandler() noexcept -> sockets::UdpSocketHandler & { return udp_socket_handler_; }
 
  auto GetDoipChannel() noexcept -> DoipUdpChannel & { return channel_; }
 
  auto GetSyncTimer() noexcept -> SyncTimer & { return sync_timer_; }
 
 private:
  sockets::UdpSocketHandler &udp_socket_handler_;
 
  DoipUdpChannel &channel_;
 
  VehicleIdentificationStateContext state_context_;
 
  SyncTimer sync_timer_;
};
 
VehicleIdentificationHandler::VehicleIdentificationHandler(
    sockets::UdpSocketHandler &udp_socket_handler, DoipUdpChannel &channel)
    : handler_impl_{
          std::make_unique<VehicleIdentificationHandlerImpl>(udp_socket_handler, channel)} {}
 
VehicleIdentificationHandler::~VehicleIdentificationHandler() = default;
 
auto VehicleIdentificationHandler::HandleVehicleIdentificationRequest(
    uds_transport::UdsMessageConstPtr vehicle_identification_request) noexcept
    -> uds_transport::UdsTransportProtocolMgr::TransmissionResult {
  uds_transport::UdsTransportProtocolMgr::TransmissionResult ret_val{
      uds_transport::UdsTransportProtocolMgr::TransmissionResult::kTransmitFailed};
  if (handler_impl_->GetStateContext().GetActiveState().GetState() ==
      VehicleIdentificationState::kIdle) {
    // change state before sending if SendVehicleIdentificationRequest call takes more time to return and in the
    // same time async reception starts
    handler_impl_->GetStateContext().TransitionTo(
        VehicleIdentificationState::kWaitForVehicleIdentificationRes);
    if (SendVehicleIdentificationRequest(std::move(vehicle_identification_request)) ==
        uds_transport::UdsTransportProtocolMgr::TransmissionResult::kTransmitOk) {
      ret_val = uds_transport::UdsTransportProtocolMgr::TransmissionResult::kTransmitOk;
      // Wait for 2 sec to collect all the vehicle identification response
      handler_impl_->GetSyncTimer().WaitForTimeout(
          [&]() {
            handler_impl_->GetStateContext().TransitionTo(
                VehicleIdentificationState::kDoIPCtrlTimeout);
            // Todo: Send data to upper layer here
          },
          [&]() {
            // no cancellation
          },
          std::chrono::milliseconds{kDoIPCtrl});
      handler_impl_->GetStateContext().TransitionTo(VehicleIdentificationState::kIdle);
    } else {
      // failed, do nothing
      handler_impl_->GetStateContext().TransitionTo(VehicleIdentificationState::kIdle);
      logger::DoipClientLogger::GetDiagClientLogger().GetLogger().LogError(
          FILE_NAME, __LINE__, "", [](std::stringstream &msg) {
            msg << "Vehicle Identification request transmission Failed";
          });
    }
  } else {
    // not free, state already in idle state
  }
  return ret_val;
}
 
void VehicleIdentificationHandler::ProcessVehicleIdentificationResponse(
    DoipMessage &doip_payload) noexcept {
  if (handler_impl_->GetStateContext().GetActiveState().GetState() ==
      VehicleIdentificationState::kWaitForVehicleIdentificationRes) {
    // Deserialize data to indicate to upper layer
    std::pair<uds_transport::UdsTransportProtocolMgr::IndicationResult,
              uds_transport::UdsMessagePtr>
        ret_val{handler_impl_->GetDoipChannel().IndicateMessage(
            static_cast<uds_transport::UdsMessage::Address>(0U),
            static_cast<uds_transport::UdsMessage::Address>(0U),
            uds_transport::UdsMessage::TargetAddressType::kPhysical, 0U,
            doip_payload.GetPayload().size(), 0U, "DoIPUdp", doip_payload.GetPayload())};
    if ((ret_val.first ==
         uds_transport::UdsTransportProtocolMgr::IndicationResult::kIndicationOk) &&
        (ret_val.second != nullptr)) {
      // Add meta info about ip address
      uds_transport::UdsMessage::MetaInfoMap meta_info_map{
          {"kRemoteIpAddress", std::string{doip_payload.GetHostIpAddress()}}};
      ret_val.second->AddMetaInfo(
          std::make_shared<uds_transport::UdsMessage::MetaInfoMap>(meta_info_map));
      // copy to application buffer
      (void) std::copy(doip_payload.GetPayload().begin(), doip_payload.GetPayload().end(),
                       ret_val.second->GetPayload().begin());
      handler_impl_->GetDoipChannel().HandleMessage(std::move(ret_val.second));
    }
  } else {
    // ignore
  }
}
 
auto VehicleIdentificationHandler::SendVehicleIdentificationRequest(
    uds_transport::UdsMessageConstPtr vehicle_identification_request) noexcept
    -> uds_transport::UdsTransportProtocolMgr::TransmissionResult {
  uds_transport::UdsTransportProtocolMgr::TransmissionResult ret_val{
      uds_transport::UdsTransportProtocolMgr::TransmissionResult::kTransmitFailed};
  // Get preselection mode
  std::uint8_t const preselection_mode{vehicle_identification_request->GetPayload()[1u]};
  // Get the payload type & length from preselection mode
  VehiclePayloadType const doip_vehicle_payload_type{
      GetVehicleIdentificationPayloadType(preselection_mode)};
 
  // create header
  UdpMessage::BufferType compose_vehicle_identification_req{
      CreateDoipGenericHeader(doip_vehicle_payload_type.first, doip_vehicle_payload_type.second)};
  // Copy only if containing VIN / EID
  if (doip_vehicle_payload_type.first != kDoip_VehicleIdentification_ReqType) {
    compose_vehicle_identification_req.insert(
        compose_vehicle_identification_req.begin() + kDoipheadrSize,
        vehicle_identification_request->GetPayload().begin() + 2U,
        vehicle_identification_request->GetPayload().end());
  }
 
  UdpMessagePtr doip_vehicle_identification_req{
      std::make_unique<UdpMessage>(vehicle_identification_request->GetHostIpAddress(),
                                   vehicle_identification_request->GetHostPortNumber(),
                                   std::move(compose_vehicle_identification_req))};
  if (handler_impl_->GetSocketHandler().Transmit(std::move(doip_vehicle_identification_req))) {
    ret_val = uds_transport::UdsTransportProtocolMgr::TransmissionResult::kTransmitOk;
  }
  return ret_val;
}
 
}  // namespace udp_channel
}  // namespace channel
}  // namespace doip_client