Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *    All rights reserved.
       5             :  *
       6             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7             :  *    you may not use this file except in compliance with the License.
       8             :  *    You may obtain a copy of the License at
       9             :  *
      10             :  *        http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  *    Unless required by applicable law or agreed to in writing, software
      13             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  *    See the License for the specific language governing permissions and
      16             :  *    limitations under the License.
      17             :  */
      18             : 
      19             : /**
      20             :  *    @file
      21             :  *      This file implements an object for a CHIP Echo unsolicited
      22             :  *      initiator (client).
      23             :  *
      24             :  */
      25             : 
      26             : #include "Echo.h"
      27             : 
      28             : namespace chip {
      29             : namespace Protocols {
      30             : namespace Echo {
      31             : 
      32             : // The Echo message timeout value in milliseconds.
      33             : constexpr System::Clock::Timeout kEchoMessageTimeout = System::Clock::Milliseconds32(800);
      34             : 
      35           0 : CHIP_ERROR EchoClient::Init(Messaging::ExchangeManager * exchangeMgr, const SessionHandle & session)
      36             : {
      37             :     // Error if already initialized.
      38           0 :     if (mExchangeMgr != nullptr)
      39           0 :         return CHIP_ERROR_INCORRECT_STATE;
      40             : 
      41           0 :     mExchangeMgr = exchangeMgr;
      42           0 :     mSecureSession.Grab(session);
      43           0 :     OnEchoResponseReceived = nullptr;
      44           0 :     mExchangeCtx           = nullptr;
      45             : 
      46           0 :     return CHIP_NO_ERROR;
      47             : }
      48             : 
      49           0 : void EchoClient::Shutdown()
      50             : {
      51           0 :     if (mExchangeCtx != nullptr)
      52             :     {
      53           0 :         mExchangeCtx->Abort();
      54           0 :         mExchangeCtx = nullptr;
      55             :     }
      56             : 
      57           0 :     OnEchoResponseReceived = nullptr;
      58           0 :     mExchangeMgr           = nullptr;
      59           0 : }
      60             : 
      61           0 : CHIP_ERROR EchoClient::SendEchoRequest(System::PacketBufferHandle && payload, Messaging::SendFlags sendFlags)
      62             : {
      63           0 :     CHIP_ERROR err = CHIP_NO_ERROR;
      64             : 
      65             :     // Discard any existing exchange context. Effectively we can only have one Echo exchange with
      66             :     // a single node at any one time.
      67           0 :     if (mExchangeCtx != nullptr)
      68             :     {
      69           0 :         mExchangeCtx->Abort();
      70           0 :         mExchangeCtx = nullptr;
      71             :     }
      72             : 
      73           0 :     VerifyOrReturnError(mSecureSession, CHIP_ERROR_INVALID_MESSAGE_TYPE);
      74             : 
      75             :     // Create a new exchange context.
      76           0 :     mExchangeCtx = mExchangeMgr->NewContext(mSecureSession.Get().Value(), this);
      77           0 :     if (mExchangeCtx == nullptr)
      78             :     {
      79           0 :         return CHIP_ERROR_NO_MEMORY;
      80             :     }
      81             : 
      82           0 :     mExchangeCtx->SetResponseTimeout(kEchoMessageTimeout);
      83             : 
      84             :     // Send an Echo Request message.  Discard the exchange context if the send fails.
      85           0 :     err = mExchangeCtx->SendMessage(MsgType::EchoRequest, std::move(payload),
      86           0 :                                     sendFlags.Set(Messaging::SendMessageFlags::kExpectResponse));
      87             : 
      88           0 :     if (err != CHIP_NO_ERROR)
      89             :     {
      90           0 :         mExchangeCtx->Abort();
      91           0 :         mExchangeCtx = nullptr;
      92             :     }
      93             : 
      94           0 :     return err;
      95             : }
      96             : 
      97           0 : CHIP_ERROR EchoClient::OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
      98             :                                          System::PacketBufferHandle && payload)
      99             : {
     100             :     // Assert that the exchange context matches the client's current context.
     101             :     // This should never fail because even if SendEchoRequest is called
     102             :     // back-to-back, the second call will call Close() on the first exchange,
     103             :     // which clears the OnMessageReceived callback.
     104           0 :     VerifyOrDie(ec == mExchangeCtx);
     105             : 
     106           0 :     mExchangeCtx = nullptr;
     107             : 
     108             :     // Verify that the message is an Echo Response.
     109           0 :     if (!payloadHeader.HasMessageType(MsgType::EchoResponse))
     110             :     {
     111           0 :         return CHIP_ERROR_INVALID_ARGUMENT;
     112             :     }
     113             : 
     114             :     // Call the registered OnEchoResponseReceived handler, if any.
     115           0 :     if (OnEchoResponseReceived != nullptr)
     116             :     {
     117           0 :         OnEchoResponseReceived(ec, std::move(payload));
     118             :     }
     119           0 :     return CHIP_NO_ERROR;
     120             : }
     121             : 
     122           0 : void EchoClient::OnResponseTimeout(Messaging::ExchangeContext * ec)
     123             : {
     124           0 :     mExchangeCtx = nullptr;
     125           0 :     ChipLogProgress(Echo, "Time out! failed to receive echo response from Exchange: %p", ec);
     126           0 : }
     127             : 
     128             : } // namespace Echo
     129             : } // namespace Protocols
     130             : } // namespace chip