Matter SDK Coverage Report
Current view: top level - app - CommandHandlerImpl.h (source / functions) Coverage Total Hit
Test: SHA:1560a87972ec2c7a76cec101927a563a6862bc2a Lines: 88.0 % 25 22
Test Date: 2025-03-30 07:08:27 Functions: 83.3 % 12 10

            Line data    Source code
       1              : /*
       2              :  *    Copyright (c) 2020-2024 Project CHIP Authors
       3              :  *    All rights reserved.
       4              :  *
       5              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6              :  *    you may not use this file except in compliance with the License.
       7              :  *    You may obtain a copy of the License at
       8              :  *
       9              :  *        http://www.apache.org/licenses/LICENSE-2.0
      10              :  *
      11              :  *    Unless required by applicable law or agreed to in writing, software
      12              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14              :  *    See the License for the specific language governing permissions and
      15              :  *    limitations under the License.
      16              :  */
      17              : #pragma once
      18              : 
      19              : #include <app/CommandHandler.h>
      20              : 
      21              : #include <app/CommandHandlerExchangeInterface.h>
      22              : #include <app/CommandHandlerInterface.h>
      23              : #include <app/CommandPathRegistry.h>
      24              : #include <app/MessageDef/InvokeRequestMessage.h>
      25              : #include <app/MessageDef/InvokeResponseMessage.h>
      26              : #include <app/data-model-provider/OperationTypes.h>
      27              : #include <lib/core/TLV.h>
      28              : #include <lib/core/TLVDebug.h>
      29              : #include <lib/support/BitFlags.h>
      30              : #include <lib/support/Scoped.h>
      31              : #include <messaging/ExchangeHolder.h>
      32              : #include <messaging/Flags.h>
      33              : #include <protocols/Protocols.h>
      34              : #include <protocols/interaction_model/Constants.h>
      35              : #include <protocols/interaction_model/StatusCode.h>
      36              : #include <system/SystemPacketBuffer.h>
      37              : #include <system/TLVPacketBufferBackingStore.h>
      38              : 
      39              : namespace chip {
      40              : namespace app {
      41              : 
      42              : class CommandHandlerImpl : public CommandHandler
      43              : {
      44              : public:
      45              :     class Callback
      46              :     {
      47              :     public:
      48           78 :         virtual ~Callback() = default;
      49              : 
      50              :         /*
      51              :          * Method that signals to a registered callback that this object
      52              :          * has completed doing useful work and is now safe for release/destruction.
      53              :          */
      54              :         virtual void OnDone(CommandHandlerImpl & apCommandObj) = 0;
      55              : 
      56              :         /**
      57              :          * Perform pre-validation that the command dispatch can be performed. In particular:
      58              :          *   - check command existence/validity
      59              :          *   - validate ACL
      60              :          *   - validate timed-invoke and fabric-scoped requirements
      61              :          *
      62              :          * Returns Status::Success if the command can be dispatched, otherwise it will
      63              :          * return the status to be forwarded to the client on failure.
      64              :          *
      65              :          * Possible error return codes:
      66              :          *   - UnsupportedEndpoint/UnsupportedCluster/UnsupportedCommand if the command path is invalid
      67              :          *   - NeedsTimedInteraction
      68              :          *   - UnsupportedAccess  (ACL failure or fabric scoped without a valid fabric index)
      69              :          *   - AccessRestricted
      70              :          */
      71              :         virtual Protocols::InteractionModel::Status ValidateCommandCanBeDispatched(const DataModel::InvokeRequest & request) = 0;
      72              : 
      73              :         /*
      74              :          * Upon processing of a CommandDataIB, this method is invoked to dispatch the command
      75              :          * to the right server-side handler provided by the application.
      76              :          */
      77              :         virtual void DispatchCommand(CommandHandlerImpl & apCommandObj, const ConcreteCommandPath & aCommandPath,
      78              :                                      TLV::TLVReader & apPayload) = 0;
      79              :     };
      80              : 
      81              :     struct InvokeResponseParameters
      82              :     {
      83            4 :         InvokeResponseParameters(const ConcreteCommandPath & aRequestCommandPath) : mRequestCommandPath(aRequestCommandPath) {}
      84              : 
      85           20 :         InvokeResponseParameters & SetStartOrEndDataStruct(bool aStartOrEndDataStruct)
      86              :         {
      87           20 :             mStartOrEndDataStruct = aStartOrEndDataStruct;
      88           20 :             return *this;
      89              :         }
      90              : 
      91              :         ConcreteCommandPath mRequestCommandPath;
      92              :         /**
      93              :          * Whether the method this is being provided to should start/end the TLV container for the CommandFields element
      94              :          * within CommandDataIB.
      95              :          */
      96              :         bool mStartOrEndDataStruct = true;
      97              :     };
      98              : 
      99              :     struct TestOnlyOverrides
     100              :     {
     101              :     public:
     102              :         CommandPathRegistry * commandPathRegistry          = nullptr;
     103              :         CommandHandlerExchangeInterface * commandResponder = nullptr;
     104              :     };
     105              : 
     106              :     /*
     107              :      * The callback passed in has to outlive this CommandHandler object.
     108              :      */
     109              :     CommandHandlerImpl(Callback * apCallback);
     110              : 
     111              :     /*
     112              :      * The destructor will also invalidate all Handles created for this CommandHandlerImpl.
     113              :      */
     114              :     virtual ~CommandHandlerImpl();
     115              : 
     116              :     /*
     117              :      * Constructor to override the number of supported paths per invoke and command responder.
     118              :      *
     119              :      * The callback and any pointers passed via TestOnlyOverrides must outlive this
     120              :      * CommandHandlerImpl object.
     121              :      *
     122              :      * For testing purposes.
     123              :      */
     124              :     CommandHandlerImpl(TestOnlyOverrides & aTestOverride, Callback * apCallback);
     125              : 
     126              :     /**************** CommandHandler interface implementation ***********************/
     127              : 
     128              :     using CommandHandler::AddResponseData;
     129              :     using CommandHandler::AddStatus;
     130              :     using CommandHandler::FallibleAddStatus;
     131              : 
     132              :     void FlushAcksRightAwayOnSlowCommand() override;
     133              : 
     134              :     CHIP_ERROR FallibleAddStatus(const ConcreteCommandPath & aRequestCommandPath,
     135              :                                  const Protocols::InteractionModel::ClusterStatusCode & aStatus,
     136              :                                  const char * context = nullptr) override;
     137              :     void AddStatus(const ConcreteCommandPath & aCommandPath, const Protocols::InteractionModel::ClusterStatusCode & aStatus,
     138              :                    const char * context = nullptr) override;
     139              : 
     140              :     CHIP_ERROR AddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
     141              :                                const DataModel::EncodableToTLV & aEncodable) override;
     142              :     void AddResponse(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
     143              :                      const DataModel::EncodableToTLV & aEncodable) override;
     144              : 
     145              :     Access::SubjectDescriptor GetSubjectDescriptor() const override;
     146              :     FabricIndex GetAccessingFabricIndex() const override;
     147              :     bool IsTimedInvoke() const override;
     148              :     Messaging::ExchangeContext * GetExchangeContext() const override;
     149              : 
     150              :     /**************** Implementation-specific logic ***********************/
     151              : 
     152              :     /*
     153              :      * Main entrypoint for this class to handle an InvokeRequestMessage.
     154              :      *
     155              :      * This function MAY call the registered OnDone callback before returning.
     156              :      * To prevent immediate OnDone invocation, callers can wrap their CommandHandlerImpl instance
     157              :      * within a CommandHandler::Handle.
     158              :      *
     159              :      * isTimedInvoke is true if and only if this is part of a Timed Invoke
     160              :      * transaction (i.e. was preceded by a Timed Request).  If we reach here,
     161              :      * the timer verification has already been done.
     162              :      *
     163              :      * commandResponder handles sending InvokeResponses, added by clusters, to the client. The
     164              :      * command responder object must outlive this CommandHandler object. It is only safe to
     165              :      * release after the caller of OnInvokeCommandRequest receives the OnDone callback.
     166              :      */
     167              :     Protocols::InteractionModel::Status OnInvokeCommandRequest(CommandHandlerExchangeInterface & commandResponder,
     168              :                                                                System::PacketBufferHandle && payload, bool isTimedInvoke);
     169              : 
     170              :     /**
     171              :      * Checks that all CommandDataIB within InvokeRequests satisfy the spec's general
     172              :      * constraints for CommandDataIB. Additionally checks that InvokeRequestMessage is
     173              :      * properly formatted.
     174              :      *
     175              :      * This also builds a registry to ensure that all commands can be responded
     176              :      * to with the data required as per spec.
     177              :      */
     178              :     CHIP_ERROR ValidateInvokeRequestMessageAndBuildRegistry(InvokeRequestMessage::Parser & invokeRequestMessage);
     179              : 
     180              :     /**
     181              :      * This adds a new CommandDataIB element into InvokeResponses for the associated
     182              :      * aRequestCommandPath. This adds up until the `CommandFields` element within
     183              :      * `CommandDataIB`.
     184              :      *
     185              :      * This call will fail if CommandHandler is already in the middle of building a
     186              :      * CommandStatusIB or CommandDataIB (i.e. something has called Prepare*, without
     187              :      * calling Finish*), or is already sending InvokeResponseMessage.
     188              :      *
     189              :      * Upon success, the caller is expected to call `FinishCommand` once they have added
     190              :      * all the fields into the CommandFields element of CommandDataIB.
     191              :      *
     192              :      * @param [in] aResponseCommandPath the concrete response path that we are sending to Requester.
     193              :      * @param [in] aPrepareParameters struct containing paramters needs for preparing a command. Data
     194              :      *             such as request path, and whether this method should start the CommandFields element within
     195              :      *             CommandDataIB.
     196              :      */
     197              :     CHIP_ERROR PrepareInvokeResponseCommand(const ConcreteCommandPath & aResponseCommandPath,
     198              :                                             const InvokeResponseParameters & aPrepareParameters);
     199              : 
     200              :     /**
     201              :      * Finishes the CommandDataIB element within the InvokeResponses.
     202              :      *
     203              :      * Caller must have first successfully called `PrepareInvokeResponseCommand`.
     204              :      *
     205              :      * @param [in] aEndDataStruct end the TLV container for the CommandFields element within
     206              :      *             CommandDataIB. This should match the boolean passed into Prepare*.
     207              :      *
     208              :      * @return CHIP_ERROR_INCORRECT_STATE
     209              :      *                      If device has not previously successfully called
     210              :      *                      `PrepareInvokeResponseCommand`.
     211              :      * @return CHIP_ERROR_BUFFER_TOO_SMALL
     212              :      *                      If writing the values needed to finish the InvokeReponseIB
     213              :      *                      with the current contents of the InvokeResponseMessage
     214              :      *                      would exceed the limit. When this error occurs, it is possible
     215              :      *                      we have already closed some of the IB Builders that were
     216              :      *                      previously started in `PrepareInvokeResponseCommand`.
     217              :      * @return CHIP_ERROR_NO_MEMORY
     218              :      *                      If TLVWriter attempted to allocate an output buffer failed due to
     219              :      *                      lack of memory.
     220              :      * @return other        Other TLVWriter related errors. Typically occurs if
     221              :      *                      `GetCommandDataIBTLVWriter()` was called and used incorrectly.
     222              :      */
     223              :     // TODO(#30453): We should be able to eliminate the chances of OOM issues with reserve.
     224              :     // This will be completed in a follow up PR.
     225              :     CHIP_ERROR FinishCommand(bool aEndDataStruct = true);
     226              : 
     227              :     TLV::TLVWriter * GetCommandDataIBTLVWriter();
     228              : 
     229              : #if CHIP_WITH_NLFAULTINJECTION
     230              : 
     231              :     enum class NlFaultInjectionType : uint8_t
     232              :     {
     233              :         SeparateResponseMessages,
     234              :         SeparateResponseMessagesAndInvertedResponseOrder,
     235              :         SkipSecondResponse
     236              :     };
     237              : 
     238              :     /**
     239              :      * @brief Sends InvokeResponseMessages with injected faults for certification testing.
     240              :      *
     241              :      * The Test Harness (TH) uses this to simulate various server response behaviors,
     242              :      * ensuring the Device Under Test (DUT) handles responses per specification.
     243              :      *
     244              :      * This function strictly validates the DUT's InvokeRequestMessage against the test plan.
     245              :      * If deviations occur, the TH terminates with a detailed error message.
     246              :      *
     247              :      * @param commandResponder commandResponder that will send the InvokeResponseMessages to the client.
     248              :      * @param payload Payload of the incoming InvokeRequestMessage from the client.
     249              :      * @param isTimedInvoke Indicates whether the interaction is timed.
     250              :      * @param faultType The specific type of fault to inject into the response.
     251              :      */
     252              :     // TODO(#30453): After refactoring CommandHandler for better unit testability, create a
     253              :     // unit test specifically for the fault injection behavior.
     254              :     void TestOnlyInvokeCommandRequestWithFaultsInjected(CommandHandlerExchangeInterface & commandResponder,
     255              :                                                         System::PacketBufferHandle && payload, bool isTimedInvoke,
     256              :                                                         NlFaultInjectionType faultType);
     257              : #endif // CHIP_WITH_NLFAULTINJECTION
     258              : 
     259              : protected:
     260              :     // Lifetime management for CommandHandler::Handle
     261              : 
     262              :     void IncrementHoldOff(Handle * apHandle) override;
     263              :     void DecrementHoldOff(Handle * apHandle) override;
     264              : 
     265              : private:
     266              :     friend class TestCommandInteraction;
     267              :     friend class CommandHandler::Handle;
     268              : 
     269              :     enum class State : uint8_t
     270              :     {
     271              :         Idle,                ///< Default state that the object starts out in, where no work has commenced
     272              :         NewResponseMessage,  ///< mInvokeResponseBuilder is ready, with no responses added.
     273              :         Preparing,           ///< We are prepaing the command or status header.
     274              :         AddingCommand,       ///< In the process of adding a command.
     275              :         AddedCommand,        ///< A command has been completely encoded and is awaiting transmission.
     276              :         DispatchResponses,   ///< The command response(s) are being dispatched.
     277              :         AwaitingDestruction, ///< The object has completed its work and is awaiting destruction by the application.
     278              :     };
     279              : 
     280              :     /**
     281              :      * @brief Best effort to add InvokeResponse to InvokeResponseMessage.
     282              :      *
     283              :      * Tries to add response using lambda. Upon failure to add response, attempts
     284              :      * to rollback the InvokeResponseMessage to a known good state. If failure is due
     285              :      * to insufficient space in the current InvokeResponseMessage:
     286              :      *  - Finalizes the current InvokeResponseMessage.
     287              :      *  - Allocates a new InvokeResponseMessage.
     288              :      *  - Reattempts to add the InvokeResponse to the new InvokeResponseMessage.
     289              :      *
     290              :      * @param [in] addResponseFunction A lambda function responsible for adding the
     291              :      *             response to the current InvokeResponseMessage.
     292              :      */
     293              :     template <typename Function>
     294           57 :     CHIP_ERROR TryAddingResponse(Function && addResponseFunction)
     295              :     {
     296              :         // Invalidate any existing rollback backups. The addResponseFunction is
     297              :         // expected to create a new backup during either PrepareInvokeResponseCommand
     298              :         // or PrepareStatus execution. Direct invocation of
     299              :         // CreateBackupForResponseRollback is avoided since the buffer used by
     300              :         // InvokeResponseMessage might not be allocated until a Prepare* function
     301              :         // is called.
     302           57 :         mRollbackBackupValid = false;
     303           57 :         CHIP_ERROR err       = addResponseFunction();
     304           57 :         if (err == CHIP_NO_ERROR)
     305              :         {
     306           52 :             return CHIP_NO_ERROR;
     307              :         }
     308              :         // The error value of RollbackResponse is not important if it fails, we prioritize
     309              :         // conveying the error generated by addResponseFunction to the caller.
     310            5 :         if (RollbackResponse() != CHIP_NO_ERROR)
     311              :         {
     312            0 :             return err;
     313              :         }
     314              :         // If we failed to add a command due to lack of space in the
     315              :         // packet, we will make another attempt to add the response using
     316              :         // an additional InvokeResponseMessage.
     317            5 :         if (mState != State::AddedCommand || err != CHIP_ERROR_NO_MEMORY)
     318              :         {
     319            2 :             return err;
     320              :         }
     321            3 :         ReturnErrorOnFailure(FinalizeInvokeResponseMessageAndPrepareNext());
     322            3 :         err = addResponseFunction();
     323            3 :         if (err != CHIP_NO_ERROR)
     324              :         {
     325              :             // The return value of RollbackResponse is ignored, as we prioritize
     326              :             // conveying the error generated by addResponseFunction to the
     327              :             // caller.
     328            0 :             RollbackResponse();
     329              :         }
     330            3 :         return err;
     331              :     }
     332              : 
     333              :     void MoveToState(const State aTargetState);
     334              :     const char * GetStateStr() const;
     335              : 
     336              :     /**
     337              :      * Create a backup to enable rolling back to the state prior to ResponseData encoding in the event of failure.
     338              :      */
     339              :     void CreateBackupForResponseRollback();
     340              : 
     341              :     /**
     342              :      * Rollback the state to before encoding the current ResponseData (before calling PrepareInvokeResponseCommand / PrepareStatus)
     343              :      *
     344              :      * Requires CreateBackupForResponseRollback to be called at the start of PrepareInvokeResponseCommand / PrepareStatus
     345              :      */
     346              :     CHIP_ERROR RollbackResponse();
     347              : 
     348              :     /*
     349              :      * This forcibly closes the exchange context if a valid one is pointed to. Such a situation does
     350              :      * not arise during normal message processing flows that all normally call Close() above. This can only
     351              :      * arise due to application-initiated destruction of the object when this object is handling receiving/sending
     352              :      * message payloads.
     353              :      */
     354              :     void Abort();
     355              : 
     356              :     /*
     357              :      * Allocates a packet buffer used for encoding an invoke response payload.
     358              :      *
     359              :      * This can be called multiple times safely, as it will only allocate the buffer once for the lifetime
     360              :      * of this object.
     361              :      */
     362              :     CHIP_ERROR AllocateBuffer();
     363              : 
     364              :     /**
     365              :      * This will add a new CommandStatusIB element into InvokeResponses. It will put the
     366              :      * aCommandPath into the CommandPath element within CommandStatusIB.
     367              :      *
     368              :      * This call will fail if CommandHandler is already in the middle of building a
     369              :      * CommandStatusIB or CommandDataIB (i.e. something has called Prepare*, without
     370              :      * calling Finish*), or is already sending InvokeResponseMessage.
     371              :      *
     372              :      * Upon success, the caller is expected to call `FinishStatus` once they have encoded
     373              :      * StatusIB.
     374              :      *
     375              :      * @param [in] aCommandPath the concrete path of the command we are responding to.
     376              :      */
     377              :     CHIP_ERROR PrepareStatus(const ConcreteCommandPath & aCommandPath);
     378              : 
     379              :     /**
     380              :      * Finishes the CommandStatusIB element within the InvokeResponses.
     381              :      *
     382              :      * Caller must have first successfully called `PrepareStatus`.
     383              :      */
     384              :     CHIP_ERROR FinishStatus();
     385              : 
     386              :     CHIP_ERROR PrepareInvokeResponseCommand(const CommandPathRegistryEntry & apCommandPathRegistryEntry,
     387              :                                             const ConcreteCommandPath & aCommandPath, bool aStartDataStruct);
     388              : 
     389           46 :     CHIP_ERROR FinalizeLastInvokeResponseMessage() { return FinalizeInvokeResponseMessage(/* aHasMoreChunks = */ false); }
     390              : 
     391              :     CHIP_ERROR FinalizeInvokeResponseMessageAndPrepareNext();
     392              : 
     393              :     CHIP_ERROR FinalizeInvokeResponseMessage(bool aHasMoreChunks);
     394              : 
     395              :     Protocols::InteractionModel::Status ProcessInvokeRequest(System::PacketBufferHandle && payload, bool isTimedInvoke);
     396              : 
     397              :     /**
     398              :      * Called internally to signal the completion of all work on this object, gracefully close the
     399              :      * exchange (by calling into the base class) and finally, signal to a registerd callback that it's
     400              :      * safe to release this object.
     401              :      */
     402              :     void Close();
     403              : 
     404              :     /**
     405              :      * ProcessCommandDataIB is only called when a unicast invoke command request is received
     406              :      * It requires the endpointId in its command path to be able to dispatch the command
     407              :      */
     408              :     Protocols::InteractionModel::Status ProcessCommandDataIB(CommandDataIB::Parser & aCommandElement);
     409              : 
     410              :     /**
     411              :      * ProcessGroupCommandDataIB is only called when a group invoke command request is received
     412              :      * It doesn't need the endpointId in it's command path since it uses the GroupId in message metadata to find it
     413              :      */
     414              :     Protocols::InteractionModel::Status ProcessGroupCommandDataIB(CommandDataIB::Parser & aCommandElement);
     415              : 
     416              :     CHIP_ERROR TryAddStatusInternal(const ConcreteCommandPath & aCommandPath, const StatusIB & aStatus);
     417              : 
     418              :     CHIP_ERROR AddStatusInternal(const ConcreteCommandPath & aCommandPath, const StatusIB & aStatus);
     419              : 
     420              :     /**
     421              :      * If this function fails, it may leave our TLV buffer in an inconsistent state.
     422              :      * Callers should snapshot as needed before calling this function, and roll back
     423              :      * as needed afterward.
     424              :      *
     425              :      * @param [in] aRequestCommandPath the concrete path of the command we are responding to
     426              :      * @param [in] aResponseCommandId the id of the command to encode
     427              :      * @param [in] aEncodable the data to encode for the given aResponseCommandId
     428              :      */
     429              :     CHIP_ERROR TryAddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
     430              :                                   const DataModel::EncodableToTLV & aEncodable);
     431              : 
     432              :     void SetExchangeInterface(CommandHandlerExchangeInterface * commandResponder);
     433              : 
     434              :     /**
     435              :      * Check whether the InvokeRequest we are handling is targeted to a group.
     436              :      */
     437          118 :     bool IsGroupRequest() { return mGroupRequest; }
     438              : 
     439          129 :     bool ResponsesAccepted() { return !(mGroupRequest || mpResponder == nullptr); }
     440              : 
     441              :     /**
     442              :      * Sets the state flag to keep the information that request we are handling is targeted to a group.
     443              :      */
     444            0 :     void SetGroupRequest(bool isGroupRequest) { mGroupRequest = isGroupRequest; }
     445              : 
     446           37 :     CommandPathRegistry & GetCommandPathRegistry() const { return *mCommandPathRegistry; }
     447              : 
     448           38 :     size_t MaxPathsPerInvoke() const { return mMaxPathsPerInvoke; }
     449              : 
     450              :     void AddToHandleList(Handle * handle);
     451              : 
     452              :     void RemoveFromHandleList(Handle * handle);
     453              : 
     454              :     void InvalidateHandles();
     455              : 
     456              :     bool TestOnlyIsInIdleState() const { return mState == State::Idle; }
     457              : 
     458              :     Callback * mpCallback = nullptr;
     459              :     InvokeResponseMessage::Builder mInvokeResponseBuilder;
     460              :     TLV::TLVType mDataElementContainerType = TLV::kTLVType_NotSpecified;
     461              :     size_t mPendingWork                    = 0;
     462              :     /* List to store all currently-outstanding Handles for this Command Handler.*/
     463              :     IntrusiveList<Handle> mpHandleList;
     464              : 
     465              :     chip::System::PacketBufferTLVWriter mCommandMessageWriter;
     466              :     TLV::TLVWriter mBackupWriter;
     467              :     size_t mMaxPathsPerInvoke = CHIP_CONFIG_MAX_PATHS_PER_INVOKE;
     468              :     // TODO(#30453): See if we can reduce this size for the default cases
     469              :     // TODO Allow flexibility in registration.
     470              :     BasicCommandPathRegistry<CHIP_CONFIG_MAX_PATHS_PER_INVOKE> mBasicCommandPathRegistry;
     471              :     CommandPathRegistry * mCommandPathRegistry = &mBasicCommandPathRegistry;
     472              :     std::optional<uint16_t> mRefForResponse;
     473              : 
     474              :     CommandHandlerExchangeInterface * mpResponder = nullptr;
     475              : 
     476              :     State mState = State::Idle;
     477              :     State mBackupState;
     478              :     ScopedChangeOnly<bool> mInternalCallToAddResponseData{ false };
     479              :     bool mSuppressResponse                 = false;
     480              :     bool mTimedRequest                     = false;
     481              :     bool mGroupRequest                     = false;
     482              :     bool mBufferAllocated                  = false;
     483              :     bool mReserveSpaceForMoreChunkMessages = false;
     484              :     // TODO(#32486): We should introduce breaking change where calls to add CommandData
     485              :     // need to use AddResponse, and not CommandHandler primitives directly using
     486              :     // GetCommandDataIBTLVWriter.
     487              :     bool mRollbackBackupValid = false;
     488              :     // If mGoneAsync is true, we have finished out initial processing of the
     489              :     // incoming invoke.  After this point, our session could go away at any
     490              :     // time.
     491              :     bool mGoneAsync = false;
     492              : };
     493              : } // namespace app
     494              : } // namespace chip
        

Generated by: LCOV version 2.0-1