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 {}
};
 
void CreateDoipGenericHeader(std::vector<std::uint8_t> &doip_header_buffer, std::uint16_t payload_type,
                             std::uint32_t payload_len) {
  doip_header_buffer.emplace_back(kDoip_ProtocolVersion);
  doip_header_buffer.emplace_back(~(static_cast<std::uint8_t>(kDoip_ProtocolVersion)));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>((payload_type & 0xFF00) >> 8));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>(payload_type & 0x00FF));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0xFF000000) >> 24));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0x00FF0000) >> 16));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>((payload_len & 0x0000FF00) >> 8));
  doip_header_buffer.emplace_back(static_cast<std::uint8_t>(payload_len & 0x000000FF));
}
 
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__, __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};
  UdpMessagePtr doip_vehicle_identification_req{std::make_unique<UdpMessage>(
      vehicle_identification_request->GetHostIpAddress(), vehicle_identification_request->GetHostPortNumber())};
 
  // Get preselection mode
  std::uint8_t preselection_mode{vehicle_identification_request->GetPayload()[BYTE_POS_ONE]};
  // Get the payload type & length from preselection mode
  VehiclePayloadType const doip_vehicle_payload_type{GetVehicleIdentificationPayloadType(preselection_mode)};
 
  // create header
  CreateDoipGenericHeader(doip_vehicle_identification_req->GetTxBuffer(), 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) {
    doip_vehicle_identification_req->GetTxBuffer().insert(
        doip_vehicle_identification_req->GetTxBuffer().begin() + kDoipheadrSize,
        vehicle_identification_request->GetPayload().begin() + 2U, vehicle_identification_request->GetPayload().end());
  }
  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