Line data    Source code

       1              : /********************************************************************************
       2              :  * Copyright (c) 2026 Accenture
       3              :  *
       4              :  * This program and the accompanying materials are made available under the
       5              :  * terms of the Apache License Version 2.0 which is available at
       6              :  * https://www.apache.org/licenses/LICENSE-2.0
       7              :  *
       8              :  * SPDX-License-Identifier: Apache-2.0
       9              :  ********************************************************************************/
      10              : 
      11              : #include "someip/ServiceHandler.h"
      12              : 
      13              : #include "someip/SomeIpParser.h"
      14              : 
      15              : namespace someip
      16              : {
      17              : // static
      18            0 : ::ip::IPEndpoint const& ServiceHandler::getEndpoint(CallDoneClosure const& done)
      19              : {
      20            0 :     return static_cast<RpcCallback const&>(done).getParam1().remoteIp;
      21              : }
      22              : 
      23            1 : void ServiceHandler::setOperationResult(CallDoneClosure& done, uint8_t const resultCode)
      24              : {
      25            1 :     uint32_t const SOMEIP_ERROR_OFFSET = 0x1FU;
      26            1 :     static_cast<RpcCallback&>(done).getParam1().operationResult
      27            1 :         = resultCode == 0U ? 0U : static_cast<uint8_t>(resultCode + SOMEIP_ERROR_OFFSET);
      28            1 : }
      29              : 
      30            3 : void ServiceHandler::dispatchMethod(
      31              :     uint16_t const methodId,
      32              :     ISomeIpSerializable const* const pRequest,
      33              :     ISomeIpSerializable* const pResponse,
      34              :     CallDoneClosure& done)
      35              : {
      36            3 :     MethodDetail const* const details = getMethodDetail(methodId);
      37              : 
      38            3 :     if (details == nullptr)
      39              :     {
      40            0 :         done(::someip::RPC_METHOD_NOT_AVAILABLE);
      41            0 :         return;
      42              :     }
      43              : 
      44            3 :     switch (details->methodType)
      45              :     {
      46            3 :         case SomeIpMethodType::METHOD_NO_PARAMETERS:
      47              :         {
      48            3 :             callMethod(methodId, nullptr, nullptr, done);
      49            3 :             break;
      50              :         }
      51            0 :         case SomeIpMethodType::METHOD_REQUEST_RESPONSE:
      52              :         {
      53            0 :             if (isRequestResponseValid(pRequest, pResponse, done))
      54              :             {
      55            0 :                 callMethod(methodId, pRequest, pResponse, done);
      56              :             }
      57            0 :             break;
      58              :         }
      59            0 :         case SomeIpMethodType::METHOD_REQUEST_ONLY:
      60              :         {
      61            0 :             if (isSerializableValid(pRequest, done))
      62              :             {
      63            0 :                 callMethod(methodId, pRequest, nullptr, done);
      64              :             }
      65            0 :             break;
      66              :         }
      67            0 :         case SomeIpMethodType::METHOD_RESPONSE_ONLY:
      68              :         {
      69            0 :             if (isSerializableValid(pResponse, done))
      70              :             {
      71            0 :                 callMethod(methodId, nullptr, pResponse, done);
      72              :             }
      73            0 :             break;
      74              :         }
      75            0 :         default:
      76              :         {
      77            0 :             done(::someip::RPC_METHOD_NOT_AVAILABLE);
      78            0 :             break;
      79              :         }
      80              :     }
      81              : }
      82              : 
      83            3 : ISomeIpSerializable* ServiceHandler::createRequest(uint16_t const methodId, SomeIpParser& parser)
      84              : {
      85            3 :     ISomeIpSerializable* const _request = getRequest(methodId);
      86              : 
      87            3 :     if (_request == nullptr)
      88              :     {
      89            3 :         return nullptr;
      90              :     }
      91              : 
      92            0 :     parser >> *_request;
      93              : 
      94            0 :     if (parser.isGood())
      95              :     {
      96            0 :         return _request;
      97              :     }
      98            0 :     return nullptr;
      99              : }
     100              : 
     101              : // static
     102            2 : bool ServiceHandler::isSerializableValid(
     103              :     ISomeIpSerializable const* const obj, CallDoneClosure& done)
     104              : {
     105            2 :     if (obj == nullptr)
     106              :     {
     107            1 :         done(::someip::RPC_INVALID_PAYLOAD);
     108            1 :         return false;
     109              :     }
     110              : 
     111            1 :     return true;
     112              : }
     113              : 
     114              : // static
     115            4 : bool ServiceHandler::isRequestResponseValid(
     116              :     ISomeIpSerializable const* const request,
     117              :     ISomeIpSerializable const* const response,
     118              :     CallDoneClosure& done)
     119              : {
     120            4 :     if ((request == nullptr) || (response == nullptr))
     121              :     {
     122            3 :         done(::someip::RPC_INVALID_PAYLOAD);
     123            3 :         return false;
     124              :     }
     125              : 
     126            1 :     return true;
     127              : }
     128              : 
     129              : } // namespace someip