Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2021 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 : #include <app/AppConfig.h>
20 : #include <app/AttributeAccessInterfaceRegistry.h>
21 : #include <app/AttributeValueDecoder.h>
22 : #include <app/ConcreteAttributePath.h>
23 : #include <app/GlobalAttributes.h>
24 : #include <app/InteractionModelEngine.h>
25 : #include <app/MessageDef/EventPathIB.h>
26 : #include <app/MessageDef/StatusIB.h>
27 : #include <app/StatusResponse.h>
28 : #include <app/WriteHandler.h>
29 : #include <app/data-model-provider/ActionReturnStatus.h>
30 : #include <app/data-model-provider/MetadataLookup.h>
31 : #include <app/data-model-provider/MetadataTypes.h>
32 : #include <app/data-model-provider/OperationTypes.h>
33 : #include <app/reporting/Engine.h>
34 : #include <app/util/MatterCallbacks.h>
35 : #include <credentials/GroupDataProvider.h>
36 : #include <lib/core/CHIPError.h>
37 : #include <lib/core/DataModelTypes.h>
38 : #include <lib/support/CodeUtils.h>
39 : #include <lib/support/TypeTraits.h>
40 : #include <lib/support/logging/TextOnlyLogging.h>
41 : #include <messaging/ExchangeContext.h>
42 : #include <protocols/interaction_model/StatusCode.h>
43 :
44 : #include <optional>
45 :
46 : namespace chip {
47 : namespace app {
48 :
49 : namespace {
50 :
51 : using Protocols::InteractionModel::Status;
52 :
53 : /// Wraps a EndpointIterator and ensures that `::Release()` is called
54 : /// for the iterator (assuming it is non-null)
55 : class AutoReleaseGroupEndpointIterator
56 : {
57 : public:
58 0 : explicit AutoReleaseGroupEndpointIterator(Credentials::GroupDataProvider::EndpointIterator * iterator) : mIterator(iterator) {}
59 0 : ~AutoReleaseGroupEndpointIterator()
60 : {
61 0 : if (mIterator != nullptr)
62 : {
63 0 : mIterator->Release();
64 : }
65 0 : }
66 :
67 0 : bool IsNull() const { return mIterator == nullptr; }
68 0 : bool Next(Credentials::GroupDataProvider::GroupEndpoint & item) { return mIterator->Next(item); }
69 :
70 : private:
71 : Credentials::GroupDataProvider::EndpointIterator * mIterator;
72 : };
73 :
74 : } // namespace
75 :
76 : using namespace Protocols::InteractionModel;
77 : using Status = Protocols::InteractionModel::Status;
78 :
79 966 : CHIP_ERROR WriteHandler::Init(DataModel::Provider * apProvider, WriteHandlerDelegate * apWriteHandlerDelegate)
80 : {
81 966 : VerifyOrReturnError(!mExchangeCtx, CHIP_ERROR_INCORRECT_STATE);
82 966 : VerifyOrReturnError(apWriteHandlerDelegate, CHIP_ERROR_INVALID_ARGUMENT);
83 966 : VerifyOrReturnError(apProvider, CHIP_ERROR_INVALID_ARGUMENT);
84 965 : mDataModelProvider = apProvider;
85 :
86 965 : mDelegate = apWriteHandlerDelegate;
87 965 : MoveToState(State::Initialized);
88 :
89 965 : mACLCheckCache.ClearValue();
90 965 : mProcessingAttributePath.ClearValue();
91 :
92 965 : return CHIP_NO_ERROR;
93 : }
94 :
95 965 : void WriteHandler::Close()
96 : {
97 965 : VerifyOrReturn(mState != State::Uninitialized);
98 :
99 : // DeliverFinalListWriteEnd will be a no-op if we have called
100 : // DeliverFinalListWriteEnd in success conditions, so passing false for
101 : // wasSuccessful here is safe: if it does anything, we were in fact not
102 : // successful.
103 965 : DeliverFinalListWriteEnd(false /* wasSuccessful */);
104 965 : mExchangeCtx.Release();
105 965 : mStateFlags.Clear(StateBits::kSuppressResponse);
106 965 : mDataModelProvider = nullptr;
107 965 : MoveToState(State::Uninitialized);
108 : }
109 :
110 1094 : std::optional<bool> WriteHandler::IsListAttributePath(const ConcreteAttributePath & path)
111 : {
112 1094 : if (mDataModelProvider == nullptr)
113 : {
114 : #if CHIP_CONFIG_DATA_MODEL_EXTRA_LOGGING
115 0 : ChipLogError(DataManagement, "Null data model while checking attribute properties.");
116 : #endif
117 0 : return std::nullopt;
118 : }
119 :
120 1094 : DataModel::AttributeFinder finder(mDataModelProvider);
121 1094 : std::optional<DataModel::AttributeEntry> info = finder.Find(path);
122 :
123 1094 : if (!info.has_value())
124 : {
125 6 : return std::nullopt;
126 : }
127 :
128 1088 : return info->HasFlags(DataModel::AttributeQualityFlags::kListAttribute);
129 1094 : }
130 :
131 3877 : Status WriteHandler::HandleWriteRequestMessage(Messaging::ExchangeContext * apExchangeContext,
132 : System::PacketBufferHandle && aPayload, bool aIsTimedWrite)
133 : {
134 3877 : System::PacketBufferHandle packet = System::PacketBufferHandle::New(chip::app::kMaxSecureSduLengthBytes);
135 3877 : VerifyOrReturnError(!packet.IsNull(), Status::Failure);
136 :
137 3877 : System::PacketBufferTLVWriter messageWriter;
138 3877 : messageWriter.Init(std::move(packet));
139 3877 : VerifyOrReturnError(mWriteResponseBuilder.Init(&messageWriter) == CHIP_NO_ERROR, Status::Failure);
140 :
141 3877 : mWriteResponseBuilder.CreateWriteResponses();
142 3877 : VerifyOrReturnError(mWriteResponseBuilder.GetError() == CHIP_NO_ERROR, Status::Failure);
143 :
144 3877 : Status status = ProcessWriteRequest(std::move(aPayload), aIsTimedWrite);
145 :
146 : // Do not send response on Group Write
147 3877 : if (status == Status::Success && !apExchangeContext->IsGroupExchangeContext())
148 : {
149 3874 : CHIP_ERROR err = SendWriteResponse(std::move(messageWriter));
150 3874 : if (err != CHIP_NO_ERROR)
151 : {
152 0 : status = Status::Failure;
153 : }
154 : }
155 :
156 3877 : return status;
157 3877 : }
158 :
159 965 : Status WriteHandler::OnWriteRequest(Messaging::ExchangeContext * apExchangeContext, System::PacketBufferHandle && aPayload,
160 : bool aIsTimedWrite)
161 : {
162 : //
163 : // Let's take over further message processing on this exchange from the IM.
164 : // This is only relevant during chunked requests.
165 : //
166 965 : mExchangeCtx.Grab(apExchangeContext);
167 :
168 965 : Status status = HandleWriteRequestMessage(apExchangeContext, std::move(aPayload), aIsTimedWrite);
169 :
170 : // The write transaction will be alive only when the message was handled successfully and there are more chunks.
171 965 : if (!(status == Status::Success && mStateFlags.Has(StateBits::kHasMoreChunks)))
172 : {
173 102 : Close();
174 : }
175 :
176 965 : return status;
177 : }
178 :
179 2913 : CHIP_ERROR WriteHandler::OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader,
180 : System::PacketBufferHandle && aPayload)
181 : {
182 2913 : CHIP_ERROR err = CHIP_NO_ERROR;
183 :
184 2913 : VerifyOrDieWithMsg(apExchangeContext == mExchangeCtx.Get(), DataManagement,
185 : "Incoming exchange context should be same as the initial request.");
186 2913 : VerifyOrDieWithMsg(!apExchangeContext->IsGroupExchangeContext(), DataManagement,
187 : "OnMessageReceived should not be called on GroupExchangeContext");
188 2913 : if (!aPayloadHeader.HasMessageType(Protocols::InteractionModel::MsgType::WriteRequest))
189 : {
190 1 : if (aPayloadHeader.HasMessageType(Protocols::InteractionModel::MsgType::StatusResponse))
191 : {
192 0 : CHIP_ERROR statusError = CHIP_NO_ERROR;
193 : // Parse the status response so we can log it properly.
194 0 : StatusResponse::ProcessStatusResponse(std::move(aPayload), statusError);
195 : }
196 1 : ChipLogDetail(DataManagement, "Unexpected message type %d", aPayloadHeader.GetMessageType());
197 1 : StatusResponse::Send(Status::InvalidAction, apExchangeContext, false /*aExpectResponse*/);
198 1 : Close();
199 1 : return CHIP_ERROR_INVALID_MESSAGE_TYPE;
200 : }
201 :
202 : Status status =
203 2912 : HandleWriteRequestMessage(apExchangeContext, std::move(aPayload), false /* chunked write should not be timed write */);
204 2912 : if (status == Status::Success)
205 : {
206 : // We have no more chunks, the write response has been sent in HandleWriteRequestMessage, so close directly.
207 2912 : if (!mStateFlags.Has(StateBits::kHasMoreChunks))
208 : {
209 853 : Close();
210 : }
211 : }
212 : else
213 : {
214 0 : err = StatusResponse::Send(status, apExchangeContext, false /*aExpectResponse*/);
215 0 : Close();
216 : }
217 2912 : return CHIP_NO_ERROR;
218 : }
219 :
220 8 : void WriteHandler::OnResponseTimeout(Messaging::ExchangeContext * apExchangeContext)
221 : {
222 8 : ChipLogError(DataManagement, "Time out! failed to receive status response from Exchange: " ChipLogFormatExchange,
223 : ChipLogValueExchange(apExchangeContext));
224 8 : Close();
225 8 : }
226 :
227 3874 : CHIP_ERROR WriteHandler::FinalizeMessage(System::PacketBufferTLVWriter && aMessageWriter, System::PacketBufferHandle & packet)
228 : {
229 3874 : VerifyOrReturnError(mState == State::AddStatus, CHIP_ERROR_INCORRECT_STATE);
230 3874 : ReturnErrorOnFailure(mWriteResponseBuilder.GetWriteResponses().EndOfAttributeStatuses());
231 3874 : ReturnErrorOnFailure(mWriteResponseBuilder.EndOfWriteResponseMessage());
232 3874 : ReturnErrorOnFailure(aMessageWriter.Finalize(&packet));
233 3874 : return CHIP_NO_ERROR;
234 : }
235 :
236 3874 : CHIP_ERROR WriteHandler::SendWriteResponse(System::PacketBufferTLVWriter && aMessageWriter)
237 : {
238 3874 : CHIP_ERROR err = CHIP_NO_ERROR;
239 3874 : System::PacketBufferHandle packet;
240 :
241 3874 : VerifyOrExit(mState == State::AddStatus, err = CHIP_ERROR_INCORRECT_STATE);
242 :
243 3874 : err = FinalizeMessage(std::move(aMessageWriter), packet);
244 3874 : SuccessOrExit(err);
245 :
246 3874 : VerifyOrExit(mExchangeCtx, err = CHIP_ERROR_INCORRECT_STATE);
247 3874 : mExchangeCtx->UseSuggestedResponseTimeout(app::kExpectedIMProcessingTime);
248 7748 : err = mExchangeCtx->SendMessage(Protocols::InteractionModel::MsgType::WriteResponse, std::move(packet),
249 3874 : mStateFlags.Has(StateBits::kHasMoreChunks) ? Messaging::SendMessageFlags::kExpectResponse
250 : : Messaging::SendMessageFlags::kNone);
251 3874 : SuccessOrExit(err);
252 :
253 3874 : MoveToState(State::Sending);
254 :
255 3874 : exit:
256 7748 : return err;
257 3874 : }
258 :
259 937 : void WriteHandler::DeliverListWriteBegin(const ConcreteAttributePath & aPath)
260 : {
261 937 : if (mDataModelProvider != nullptr)
262 : {
263 937 : mDataModelProvider->ListAttributeWriteNotification(aPath, DataModel::ListWriteOperation::kListWriteBegin);
264 : }
265 937 : }
266 :
267 942 : void WriteHandler::DeliverListWriteEnd(const ConcreteAttributePath & aPath, bool writeWasSuccessful)
268 : {
269 942 : if (mDataModelProvider != nullptr)
270 : {
271 942 : mDataModelProvider->ListAttributeWriteNotification(aPath,
272 : writeWasSuccessful ? DataModel::ListWriteOperation::kListWriteSuccess
273 : : DataModel::ListWriteOperation::kListWriteFailure);
274 : }
275 942 : }
276 :
277 1917 : void WriteHandler::DeliverFinalListWriteEnd(bool writeWasSuccessful)
278 : {
279 1917 : if (mProcessingAttributePath.HasValue() && mStateFlags.Has(StateBits::kProcessingAttributeIsList))
280 : {
281 934 : DeliverListWriteEnd(mProcessingAttributePath.Value(), writeWasSuccessful);
282 : }
283 1917 : mProcessingAttributePath.ClearValue();
284 1917 : }
285 :
286 0 : CHIP_ERROR WriteHandler::DeliverFinalListWriteEndForGroupWrite(bool writeWasSuccessful)
287 : {
288 0 : VerifyOrReturnError(mProcessingAttributePath.HasValue() && mStateFlags.Has(StateBits::kProcessingAttributeIsList),
289 : CHIP_NO_ERROR);
290 :
291 0 : Credentials::GroupDataProvider::GroupEndpoint mapping;
292 0 : Credentials::GroupDataProvider * groupDataProvider = Credentials::GetGroupDataProvider();
293 : Credentials::GroupDataProvider::EndpointIterator * iterator;
294 :
295 0 : GroupId groupId = mExchangeCtx->GetSessionHandle()->AsIncomingGroupSession()->GetGroupId();
296 0 : FabricIndex fabricIndex = GetAccessingFabricIndex();
297 :
298 0 : auto processingConcreteAttributePath = mProcessingAttributePath.Value();
299 0 : mProcessingAttributePath.ClearValue();
300 :
301 0 : iterator = groupDataProvider->IterateEndpoints(fabricIndex);
302 0 : VerifyOrReturnError(iterator != nullptr, CHIP_ERROR_NO_MEMORY);
303 :
304 0 : while (iterator->Next(mapping))
305 : {
306 0 : if (groupId != mapping.group_id)
307 : {
308 0 : continue;
309 : }
310 :
311 0 : processingConcreteAttributePath.mEndpointId = mapping.endpoint_id;
312 :
313 0 : VerifyOrReturnError(mDelegate, CHIP_ERROR_INCORRECT_STATE);
314 0 : if (!mDelegate->HasConflictWriteRequests(this, processingConcreteAttributePath))
315 : {
316 0 : DeliverListWriteEnd(processingConcreteAttributePath, writeWasSuccessful);
317 : }
318 : }
319 0 : iterator->Release();
320 0 : return CHIP_NO_ERROR;
321 : }
322 : namespace {
323 :
324 : // To reduce the various use of previousProcessed.HasValue() && previousProcessed.Value() == nextAttribute to save code size.
325 14503 : bool IsSameAttribute(const Optional<ConcreteAttributePath> & previousProcessed, const ConcreteDataAttributePath & nextAttribute)
326 : {
327 14503 : return previousProcessed.HasValue() && previousProcessed.Value() == nextAttribute;
328 : }
329 :
330 5207 : bool ShouldReportListWriteEnd(const Optional<ConcreteAttributePath> & previousProcessed, bool previousProcessedAttributeIsList,
331 : const ConcreteDataAttributePath & nextAttribute)
332 : {
333 5207 : return previousProcessedAttributeIsList && !IsSameAttribute(previousProcessed, nextAttribute) && previousProcessed.HasValue();
334 : }
335 :
336 5207 : bool ShouldReportListWriteBegin(const Optional<ConcreteAttributePath> & previousProcessed, bool previousProcessedAttributeIsList,
337 : const ConcreteDataAttributePath & nextAttribute)
338 : {
339 5207 : return !IsSameAttribute(previousProcessed, nextAttribute) && nextAttribute.IsListOperation();
340 : }
341 :
342 : } // namespace
343 :
344 3874 : CHIP_ERROR WriteHandler::ProcessAttributeDataIBs(TLV::TLVReader & aAttributeDataIBsReader)
345 : {
346 3874 : CHIP_ERROR err = CHIP_NO_ERROR;
347 :
348 3874 : VerifyOrReturnError(mExchangeCtx, CHIP_ERROR_INTERNAL);
349 3874 : const Access::SubjectDescriptor subjectDescriptor = mExchangeCtx->GetSessionHandle()->GetSubjectDescriptor();
350 :
351 9094 : while (CHIP_NO_ERROR == (err = aAttributeDataIBsReader.Next()))
352 : {
353 5220 : chip::TLV::TLVReader dataReader;
354 5220 : AttributeDataIB::Parser element;
355 5220 : AttributePathIB::Parser attributePath;
356 5220 : ConcreteDataAttributePath dataAttributePath;
357 5220 : TLV::TLVReader reader = aAttributeDataIBsReader;
358 :
359 5220 : err = element.Init(reader);
360 5220 : SuccessOrExit(err);
361 :
362 5220 : err = element.GetPath(&attributePath);
363 5220 : SuccessOrExit(err);
364 :
365 5220 : err = attributePath.GetConcreteAttributePath(dataAttributePath);
366 5220 : SuccessOrExit(err);
367 :
368 5220 : err = element.GetData(&dataReader);
369 5220 : SuccessOrExit(err);
370 :
371 5220 : if (!dataAttributePath.IsListOperation() && IsListAttributePath(dataAttributePath).value_or(false))
372 : {
373 1065 : dataAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::ReplaceAll;
374 : }
375 :
376 5220 : VerifyOrExit(mDelegate, err = CHIP_ERROR_INCORRECT_STATE);
377 14552 : if (mDelegate->HasConflictWriteRequests(this, dataAttributePath) ||
378 : // Per chunking protocol, we are processing the list entries, but the initial empty list is not processed, so we reject
379 : // it with Busy status code.
380 9332 : (dataAttributePath.IsListItemOperation() && !IsSameAttribute(mProcessingAttributePath, dataAttributePath)))
381 : {
382 13 : err = AddStatusInternal(dataAttributePath, StatusIB(Status::Busy));
383 13 : continue;
384 : }
385 :
386 5207 : if (ShouldReportListWriteEnd(mProcessingAttributePath, mStateFlags.Has(StateBits::kProcessingAttributeIsList),
387 : dataAttributePath))
388 : {
389 8 : DeliverListWriteEnd(mProcessingAttributePath.Value(), mStateFlags.Has(StateBits::kAttributeWriteSuccessful));
390 : }
391 :
392 5207 : if (ShouldReportListWriteBegin(mProcessingAttributePath, mStateFlags.Has(StateBits::kProcessingAttributeIsList),
393 : dataAttributePath))
394 : {
395 937 : DeliverListWriteBegin(dataAttributePath);
396 937 : mStateFlags.Set(StateBits::kAttributeWriteSuccessful);
397 : }
398 :
399 5207 : mStateFlags.Set(StateBits::kProcessingAttributeIsList, dataAttributePath.IsListOperation());
400 5207 : mProcessingAttributePath.SetValue(dataAttributePath);
401 :
402 5207 : DataModelCallbacks::GetInstance()->AttributeOperation(DataModelCallbacks::OperationType::Write,
403 : DataModelCallbacks::OperationOrder::Pre, dataAttributePath);
404 :
405 5207 : TLV::TLVWriter backup;
406 5207 : DataVersion version = 0;
407 5207 : mWriteResponseBuilder.GetWriteResponses().Checkpoint(backup);
408 5207 : err = element.GetDataVersion(&version);
409 5207 : if (CHIP_NO_ERROR == err)
410 : {
411 12 : dataAttributePath.mDataVersion.SetValue(version);
412 : }
413 5195 : else if (CHIP_END_OF_TLV == err)
414 : {
415 5195 : err = CHIP_NO_ERROR;
416 : }
417 5207 : SuccessOrExit(err);
418 5207 : err = WriteClusterData(subjectDescriptor, dataAttributePath, dataReader);
419 5207 : if (err != CHIP_NO_ERROR)
420 : {
421 0 : mWriteResponseBuilder.GetWriteResponses().Rollback(backup);
422 0 : err = AddStatusInternal(dataAttributePath, StatusIB(err));
423 : }
424 :
425 5207 : DataModelCallbacks::GetInstance()->AttributeOperation(DataModelCallbacks::OperationType::Write,
426 : DataModelCallbacks::OperationOrder::Post, dataAttributePath);
427 5207 : SuccessOrExit(err);
428 : }
429 :
430 3874 : if (CHIP_END_OF_TLV == err)
431 : {
432 3874 : err = CHIP_NO_ERROR;
433 : }
434 :
435 3874 : SuccessOrExit(err);
436 :
437 3874 : if (!mStateFlags.Has(StateBits::kHasMoreChunks))
438 : {
439 952 : DeliverFinalListWriteEnd(mStateFlags.Has(StateBits::kAttributeWriteSuccessful));
440 : }
441 :
442 2922 : exit:
443 3874 : return err;
444 : }
445 :
446 0 : CHIP_ERROR WriteHandler::ProcessGroupAttributeDataIBs(TLV::TLVReader & aAttributeDataIBsReader)
447 : {
448 0 : CHIP_ERROR err = CHIP_NO_ERROR;
449 :
450 0 : VerifyOrReturnError(mExchangeCtx, CHIP_ERROR_INTERNAL);
451 : const Access::SubjectDescriptor subjectDescriptor =
452 0 : mExchangeCtx->GetSessionHandle()->AsIncomingGroupSession()->GetSubjectDescriptor();
453 :
454 0 : GroupId groupId = mExchangeCtx->GetSessionHandle()->AsIncomingGroupSession()->GetGroupId();
455 0 : FabricIndex fabric = GetAccessingFabricIndex();
456 :
457 0 : while (CHIP_NO_ERROR == (err = aAttributeDataIBsReader.Next()))
458 : {
459 0 : chip::TLV::TLVReader dataReader;
460 0 : AttributeDataIB::Parser element;
461 0 : AttributePathIB::Parser attributePath;
462 0 : ConcreteDataAttributePath dataAttributePath;
463 0 : TLV::TLVReader reader = aAttributeDataIBsReader;
464 :
465 0 : err = element.Init(reader);
466 0 : SuccessOrExit(err);
467 :
468 0 : err = element.GetPath(&attributePath);
469 0 : SuccessOrExit(err);
470 :
471 0 : err = attributePath.GetGroupAttributePath(dataAttributePath);
472 0 : SuccessOrExit(err);
473 :
474 0 : err = element.GetData(&dataReader);
475 0 : SuccessOrExit(err);
476 :
477 0 : if (!dataAttributePath.IsListOperation() && dataReader.GetType() == TLV::TLVType::kTLVType_Array)
478 : {
479 0 : dataAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::ReplaceAll;
480 : }
481 :
482 0 : ChipLogDetail(DataManagement,
483 : "Received group attribute write for Group=%u Cluster=" ChipLogFormatMEI " attribute=" ChipLogFormatMEI,
484 : groupId, ChipLogValueMEI(dataAttributePath.mClusterId), ChipLogValueMEI(dataAttributePath.mAttributeId));
485 :
486 0 : AutoReleaseGroupEndpointIterator iterator(Credentials::GetGroupDataProvider()->IterateEndpoints(fabric));
487 0 : VerifyOrExit(!iterator.IsNull(), err = CHIP_ERROR_NO_MEMORY);
488 :
489 0 : bool shouldReportListWriteEnd = ShouldReportListWriteEnd(
490 0 : mProcessingAttributePath, mStateFlags.Has(StateBits::kProcessingAttributeIsList), dataAttributePath);
491 0 : bool shouldReportListWriteBegin = false; // This will be set below.
492 :
493 0 : std::optional<bool> isListAttribute = std::nullopt;
494 :
495 0 : Credentials::GroupDataProvider::GroupEndpoint mapping;
496 0 : while (iterator.Next(mapping))
497 : {
498 0 : if (groupId != mapping.group_id)
499 : {
500 0 : continue;
501 : }
502 :
503 0 : dataAttributePath.mEndpointId = mapping.endpoint_id;
504 :
505 : // Try to get the metadata from for the attribute from one of the expanded endpoints (it doesn't really matter which
506 : // endpoint we pick, as long as it's valid) and update the path info according to it and recheck if we need to report
507 : // list write begin.
508 0 : if (!isListAttribute.has_value())
509 : {
510 0 : isListAttribute = IsListAttributePath(dataAttributePath);
511 0 : bool currentAttributeIsList = isListAttribute.value_or(false);
512 :
513 0 : if (!dataAttributePath.IsListOperation() && currentAttributeIsList)
514 : {
515 0 : dataAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::ReplaceAll;
516 : }
517 : ConcreteDataAttributePath pathForCheckingListWriteBegin(kInvalidEndpointId, dataAttributePath.mClusterId,
518 0 : dataAttributePath.mEndpointId, dataAttributePath.mListOp,
519 0 : dataAttributePath.mListIndex);
520 : shouldReportListWriteBegin =
521 0 : ShouldReportListWriteBegin(mProcessingAttributePath, mStateFlags.Has(StateBits::kProcessingAttributeIsList),
522 : pathForCheckingListWriteBegin);
523 : }
524 :
525 0 : if (shouldReportListWriteEnd)
526 : {
527 0 : auto processingConcreteAttributePath = mProcessingAttributePath.Value();
528 0 : processingConcreteAttributePath.mEndpointId = mapping.endpoint_id;
529 0 : VerifyOrExit(mDelegate, err = CHIP_ERROR_INCORRECT_STATE);
530 0 : if (mDelegate->HasConflictWriteRequests(this, processingConcreteAttributePath))
531 : {
532 0 : DeliverListWriteEnd(processingConcreteAttributePath, true /* writeWasSuccessful */);
533 : }
534 : }
535 :
536 0 : VerifyOrExit(mDelegate, err = CHIP_ERROR_INCORRECT_STATE);
537 0 : if (mDelegate->HasConflictWriteRequests(this, dataAttributePath))
538 : {
539 0 : ChipLogDetail(DataManagement,
540 : "Writing attribute endpoint=%u Cluster=" ChipLogFormatMEI " attribute=" ChipLogFormatMEI
541 : " is conflict with other write transactions.",
542 : mapping.endpoint_id, ChipLogValueMEI(dataAttributePath.mClusterId),
543 : ChipLogValueMEI(dataAttributePath.mAttributeId));
544 0 : continue;
545 : }
546 :
547 0 : if (shouldReportListWriteBegin)
548 : {
549 0 : DeliverListWriteBegin(dataAttributePath);
550 : }
551 :
552 0 : ChipLogDetail(DataManagement,
553 : "Processing group attribute write for endpoint=%u Cluster=" ChipLogFormatMEI
554 : " attribute=" ChipLogFormatMEI,
555 : mapping.endpoint_id, ChipLogValueMEI(dataAttributePath.mClusterId),
556 : ChipLogValueMEI(dataAttributePath.mAttributeId));
557 :
558 0 : chip::TLV::TLVReader tmpDataReader(dataReader);
559 :
560 0 : DataModelCallbacks::GetInstance()->AttributeOperation(DataModelCallbacks::OperationType::Write,
561 : DataModelCallbacks::OperationOrder::Pre, dataAttributePath);
562 0 : err = WriteClusterData(subjectDescriptor, dataAttributePath, tmpDataReader);
563 0 : if (err != CHIP_NO_ERROR)
564 : {
565 0 : ChipLogError(DataManagement,
566 : "WriteClusterData Endpoint=%u Cluster=" ChipLogFormatMEI " Attribute =" ChipLogFormatMEI
567 : " failed: %" CHIP_ERROR_FORMAT,
568 : mapping.endpoint_id, ChipLogValueMEI(dataAttributePath.mClusterId),
569 : ChipLogValueMEI(dataAttributePath.mAttributeId), err.Format());
570 : }
571 0 : DataModelCallbacks::GetInstance()->AttributeOperation(DataModelCallbacks::OperationType::Write,
572 : DataModelCallbacks::OperationOrder::Post, dataAttributePath);
573 : }
574 :
575 0 : dataAttributePath.mEndpointId = kInvalidEndpointId;
576 0 : mStateFlags.Set(StateBits::kProcessingAttributeIsList, dataAttributePath.IsListOperation());
577 0 : mProcessingAttributePath.SetValue(dataAttributePath);
578 0 : }
579 :
580 0 : if (CHIP_END_OF_TLV == err)
581 : {
582 0 : err = CHIP_NO_ERROR;
583 : }
584 :
585 0 : err = DeliverFinalListWriteEndForGroupWrite(true);
586 :
587 0 : exit:
588 : // The DeliverFinalListWriteEndForGroupWrite above will deliver the successful state of the list write and clear the
589 : // mProcessingAttributePath making the following call no-op. So we call it again after the exit label to deliver a failure state
590 : // to the clusters. Ignore the error code since we need to deliver other more important failures.
591 0 : DeliverFinalListWriteEndForGroupWrite(false);
592 0 : return err;
593 : }
594 :
595 3877 : Status WriteHandler::ProcessWriteRequest(System::PacketBufferHandle && aPayload, bool aIsTimedWrite)
596 : {
597 3877 : CHIP_ERROR err = CHIP_NO_ERROR;
598 3877 : System::PacketBufferTLVReader reader;
599 :
600 3877 : WriteRequestMessage::Parser writeRequestParser;
601 3877 : AttributeDataIBs::Parser AttributeDataIBsParser;
602 3877 : TLV::TLVReader AttributeDataIBsReader;
603 : // Default to InvalidAction for our status; that's what we want if any of
604 : // the parsing of our overall structure or paths fails. Once we have a
605 : // successfully parsed path, the only way we will get a failure return is if
606 : // our path handling fails to AddStatus on us.
607 : //
608 : // TODO: That's not technically InvalidAction, and we should probably make
609 : // our callees hand out Status as well.
610 3877 : Status status = Status::InvalidAction;
611 :
612 3877 : mLastSuccessfullyWrittenPath = std::nullopt;
613 :
614 3877 : reader.Init(std::move(aPayload));
615 :
616 3877 : err = writeRequestParser.Init(reader);
617 3877 : SuccessOrExit(err);
618 :
619 : #if CHIP_CONFIG_IM_PRETTY_PRINT
620 3876 : writeRequestParser.PrettyPrint();
621 : #endif // CHIP_CONFIG_IM_PRETTY_PRINT
622 : bool boolValue;
623 :
624 3876 : boolValue = mStateFlags.Has(StateBits::kSuppressResponse);
625 3876 : err = writeRequestParser.GetSuppressResponse(&boolValue);
626 3876 : if (err == CHIP_END_OF_TLV)
627 : {
628 4 : err = CHIP_NO_ERROR;
629 : }
630 3876 : SuccessOrExit(err);
631 3876 : mStateFlags.Set(StateBits::kSuppressResponse, boolValue);
632 :
633 3876 : boolValue = mStateFlags.Has(StateBits::kIsTimedRequest);
634 3876 : err = writeRequestParser.GetTimedRequest(&boolValue);
635 3876 : SuccessOrExit(err);
636 3876 : mStateFlags.Set(StateBits::kIsTimedRequest, boolValue);
637 :
638 3876 : boolValue = mStateFlags.Has(StateBits::kHasMoreChunks);
639 3876 : err = writeRequestParser.GetMoreChunkedMessages(&boolValue);
640 3876 : if (err == CHIP_ERROR_END_OF_TLV)
641 : {
642 4 : err = CHIP_NO_ERROR;
643 : }
644 3876 : SuccessOrExit(err);
645 3876 : mStateFlags.Set(StateBits::kHasMoreChunks, boolValue);
646 :
647 9720 : if (mStateFlags.Has(StateBits::kHasMoreChunks) &&
648 5844 : (mExchangeCtx->IsGroupExchangeContext() || mStateFlags.Has(StateBits::kIsTimedRequest)))
649 : {
650 : // Sanity check: group exchange context should only have one chunk.
651 : // Also, timed requests should not have more than one chunk.
652 0 : ExitNow(err = CHIP_ERROR_INVALID_MESSAGE_TYPE);
653 : }
654 :
655 3876 : err = writeRequestParser.GetWriteRequests(&AttributeDataIBsParser);
656 3876 : SuccessOrExit(err);
657 :
658 3876 : if (mStateFlags.Has(StateBits::kIsTimedRequest) != aIsTimedWrite)
659 : {
660 : // The message thinks it should be part of a timed interaction but it's
661 : // not, or vice versa.
662 2 : status = Status::TimedRequestMismatch;
663 2 : goto exit;
664 : }
665 :
666 3874 : AttributeDataIBsParser.GetReader(&AttributeDataIBsReader);
667 :
668 3874 : if (mExchangeCtx->IsGroupExchangeContext())
669 : {
670 0 : err = ProcessGroupAttributeDataIBs(AttributeDataIBsReader);
671 : }
672 : else
673 : {
674 3874 : err = ProcessAttributeDataIBs(AttributeDataIBsReader);
675 : }
676 3874 : SuccessOrExit(err);
677 3874 : SuccessOrExit(err = writeRequestParser.ExitContainer());
678 :
679 3874 : if (err == CHIP_NO_ERROR)
680 : {
681 3874 : status = Status::Success;
682 : }
683 :
684 0 : exit:
685 3877 : if (err != CHIP_NO_ERROR)
686 : {
687 1 : ChipLogError(DataManagement, "Failed to process write request: %" CHIP_ERROR_FORMAT, err.Format());
688 : }
689 7754 : return status;
690 3877 : }
691 :
692 0 : CHIP_ERROR WriteHandler::AddStatus(const ConcreteDataAttributePath & aPath,
693 : const Protocols::InteractionModel::ClusterStatusCode & aStatus)
694 : {
695 0 : return AddStatusInternal(aPath, StatusIB{ aStatus });
696 : }
697 :
698 0 : CHIP_ERROR WriteHandler::AddClusterSpecificSuccess(const ConcreteDataAttributePath & aPath, ClusterStatus aClusterStatus)
699 : {
700 0 : return AddStatus(aPath, Protocols::InteractionModel::ClusterStatusCode::ClusterSpecificSuccess(aClusterStatus));
701 : }
702 :
703 0 : CHIP_ERROR WriteHandler::AddClusterSpecificFailure(const ConcreteDataAttributePath & aPath, ClusterStatus aClusterStatus)
704 : {
705 0 : return AddStatus(aPath, Protocols::InteractionModel::ClusterStatusCode::ClusterSpecificFailure(aClusterStatus));
706 : }
707 :
708 5220 : CHIP_ERROR WriteHandler::AddStatusInternal(const ConcreteDataAttributePath & aPath, const StatusIB & aStatus)
709 : {
710 5220 : AttributeStatusIBs::Builder & writeResponses = mWriteResponseBuilder.GetWriteResponses();
711 5220 : AttributeStatusIB::Builder & attributeStatusIB = writeResponses.CreateAttributeStatus();
712 :
713 5220 : if (!aStatus.IsSuccess())
714 : {
715 49 : mStateFlags.Clear(StateBits::kAttributeWriteSuccessful);
716 : }
717 :
718 5220 : ReturnErrorOnFailure(writeResponses.GetError());
719 :
720 5220 : AttributePathIB::Builder & path = attributeStatusIB.CreatePath();
721 5220 : ReturnErrorOnFailure(attributeStatusIB.GetError());
722 5220 : ReturnErrorOnFailure(path.Encode(aPath));
723 :
724 5220 : StatusIB::Builder & statusIBBuilder = attributeStatusIB.CreateErrorStatus();
725 5220 : ReturnErrorOnFailure(attributeStatusIB.GetError());
726 5220 : statusIBBuilder.EncodeStatusIB(aStatus);
727 5220 : ReturnErrorOnFailure(statusIBBuilder.GetError());
728 5220 : ReturnErrorOnFailure(attributeStatusIB.EndOfAttributeStatusIB());
729 :
730 5220 : MoveToState(State::AddStatus);
731 5220 : return CHIP_NO_ERROR;
732 : }
733 :
734 1 : FabricIndex WriteHandler::GetAccessingFabricIndex() const
735 : {
736 1 : return mExchangeCtx->GetSessionHandle()->GetFabricIndex();
737 : }
738 :
739 11024 : const char * WriteHandler::GetStateStr() const
740 : {
741 : #if CHIP_DETAIL_LOGGING
742 11024 : switch (mState)
743 : {
744 965 : case State::Uninitialized:
745 965 : return "Uninitialized";
746 :
747 965 : case State::Initialized:
748 965 : return "Initialized";
749 :
750 5220 : case State::AddStatus:
751 5220 : return "AddStatus";
752 3874 : case State::Sending:
753 3874 : return "Sending";
754 : }
755 : #endif // CHIP_DETAIL_LOGGING
756 0 : return "N/A";
757 : }
758 :
759 11024 : void WriteHandler::MoveToState(const State aTargetState)
760 : {
761 11024 : mState = aTargetState;
762 11024 : ChipLogDetail(DataManagement, "IM WH moving to [%s]", GetStateStr());
763 11024 : }
764 :
765 5207 : DataModel::ActionReturnStatus WriteHandler::CheckWriteAllowed(const Access::SubjectDescriptor & aSubject,
766 : const ConcreteDataAttributePath & aPath)
767 : {
768 :
769 : // Execute the ACL Access Granting Algorithm before existence checks, assuming the required_privilege for the element is
770 : // View, to determine if the subject would have had at least some access against the concrete path. This is done so we don't
771 : // leak information if we do fail existence checks.
772 : // SPEC-DIVERGENCE: For non-concrete paths, the spec mandates only one ACL check (the one after the existence check), unlike the
773 : // concrete path case, when there is one ACL check before existence check and a second one after. However, because this code is
774 : // also used in the group path case, we end up performing an ADDITIONAL ACL check before the existence check. In practice, this
775 : // divergence is not observable.
776 5207 : Status writeAccessStatus = CheckWriteAccess(aSubject, aPath, Access::Privilege::kView);
777 5207 : VerifyOrReturnValue(writeAccessStatus == Status::Success, writeAccessStatus);
778 :
779 5204 : DataModel::AttributeFinder finder(mDataModelProvider);
780 :
781 5204 : std::optional<DataModel::AttributeEntry> attributeEntry = finder.Find(aPath);
782 :
783 : // if path is not valid, return a spec-compliant return code.
784 5204 : if (!attributeEntry.has_value())
785 : {
786 3 : return DataModel::ValidateClusterPath(mDataModelProvider, aPath, Status::UnsupportedAttribute);
787 : }
788 :
789 : // Allow writes on writable attributes only
790 5201 : VerifyOrReturnValue(attributeEntry->GetWritePrivilege().has_value(), Status::UnsupportedWrite);
791 :
792 : // Execute the ACL Access Granting Algorithm against the concrete path a second time, using the actual required_privilege
793 5201 : writeAccessStatus = CheckWriteAccess(aSubject, aPath, *attributeEntry->GetWritePrivilege());
794 5201 : VerifyOrReturnValue(writeAccessStatus == Status::Success, writeAccessStatus);
795 :
796 : // SPEC:
797 : // If the path indicates specific attribute data that requires a Timed Write
798 : // transaction to write and this action is not part of a Timed Write transaction,
799 : // an AttributeStatusIB SHALL be generated with the NEEDS_TIMED_INTERACTION Status Code.
800 5201 : VerifyOrReturnValue(IsTimedWrite() || !attributeEntry->HasFlags(DataModel::AttributeQualityFlags::kTimed),
801 : Status::NeedsTimedInteraction);
802 :
803 : // SPEC:
804 : // Else if the attribute in the path indicates a fabric-scoped list and there is no accessing
805 : // fabric, an AttributeStatusIB SHALL be generated with the UNSUPPORTED_ACCESS Status Code,
806 : // with the Path field indicating only the path to the attribute.
807 10359 : if (attributeEntry->HasFlags(DataModel::AttributeQualityFlags::kListAttribute) &&
808 5158 : attributeEntry->HasFlags(DataModel::AttributeQualityFlags::kFabricScoped))
809 : {
810 0 : VerifyOrReturnError(aSubject.fabricIndex != kUndefinedFabricIndex, Status::UnsupportedAccess);
811 : }
812 :
813 : // SPEC:
814 : // Else if the DataVersion field of the AttributeDataIB is present and does not match the
815 : // data version of the indicated cluster instance, an AttributeStatusIB SHALL be generated
816 : // with the DATA_VERSION_MISMATCH Status Code.
817 5201 : if (aPath.mDataVersion.HasValue())
818 : {
819 12 : DataModel::ServerClusterFinder clusterFinder(mDataModelProvider);
820 12 : std::optional<DataModel::ServerClusterEntry> cluster_entry = clusterFinder.Find(aPath);
821 :
822 : // path is valid based on above checks (we have an attribute entry)
823 12 : VerifyOrDie(cluster_entry.has_value());
824 12 : VerifyOrReturnValue(cluster_entry->dataVersion == aPath.mDataVersion.Value(), Status::DataVersionMismatch);
825 12 : }
826 :
827 5195 : return Status::Success;
828 5204 : }
829 :
830 10408 : Status WriteHandler::CheckWriteAccess(const Access::SubjectDescriptor & aSubject, const ConcreteAttributePath & aPath,
831 : const Access::Privilege aRequiredPrivilege)
832 : {
833 :
834 10408 : bool checkAcl = true;
835 10408 : if (mLastSuccessfullyWrittenPath.has_value())
836 : {
837 : // only validate ACL if path has changed
838 : //
839 : // Note that this is NOT operator==: we could do `checkAcl == (aPath != *mLastSuccessfullyWrittenPath)`
840 : // however that seems to use more flash.
841 2648 : if ((aPath.mEndpointId == mLastSuccessfullyWrittenPath->mEndpointId) &&
842 5296 : (aPath.mClusterId == mLastSuccessfullyWrittenPath->mClusterId) &&
843 2648 : (aPath.mAttributeId == mLastSuccessfullyWrittenPath->mAttributeId))
844 : {
845 2632 : checkAcl = false;
846 : }
847 : }
848 :
849 10408 : if (checkAcl)
850 : {
851 7776 : Access::RequestPath requestPath{ .cluster = aPath.mClusterId,
852 7776 : .endpoint = aPath.mEndpointId,
853 : .requestType = Access::RequestType::kAttributeWriteRequest,
854 7776 : .entityId = aPath.mAttributeId };
855 :
856 7776 : CHIP_ERROR err = Access::GetAccessControl().Check(aSubject, requestPath, aRequiredPrivilege);
857 :
858 7776 : if (err == CHIP_NO_ERROR)
859 : {
860 7773 : return Status::Success;
861 : }
862 :
863 3 : if (err == CHIP_ERROR_ACCESS_DENIED)
864 : {
865 3 : return Status::UnsupportedAccess;
866 : }
867 :
868 0 : if (err == CHIP_ERROR_ACCESS_RESTRICTED_BY_ARL)
869 : {
870 0 : return Status::AccessRestricted;
871 : }
872 :
873 0 : return Status::Failure;
874 : }
875 :
876 2632 : return Status::Success;
877 : }
878 :
879 5207 : CHIP_ERROR WriteHandler::WriteClusterData(const Access::SubjectDescriptor & aSubject, const ConcreteDataAttributePath & aPath,
880 : TLV::TLVReader & aData)
881 : {
882 : // Writes do not have a checked-path. If data model interface is enabled (both checked and only version)
883 : // the write is done via the DataModel interface
884 5207 : VerifyOrReturnError(mDataModelProvider != nullptr, CHIP_ERROR_INCORRECT_STATE);
885 :
886 5207 : ChipLogDetail(DataManagement, "Writing attribute: Cluster=" ChipLogFormatMEI " Endpoint=0x%x AttributeId=" ChipLogFormatMEI,
887 : ChipLogValueMEI(aPath.mClusterId), aPath.mEndpointId, ChipLogValueMEI(aPath.mAttributeId));
888 :
889 5207 : DataModel::ActionReturnStatus status = CheckWriteAllowed(aSubject, aPath);
890 5207 : if (status.IsSuccess())
891 : {
892 5195 : DataModel::WriteAttributeRequest request;
893 :
894 5195 : request.path = aPath;
895 5195 : request.subjectDescriptor = &aSubject;
896 5195 : request.writeFlags.Set(DataModel::WriteFlags::kTimed, IsTimedWrite());
897 :
898 5195 : AttributeValueDecoder decoder(aData, aSubject);
899 5195 : status = mDataModelProvider->WriteAttribute(request, decoder);
900 : }
901 :
902 5207 : mLastSuccessfullyWrittenPath = status.IsSuccess() ? std::make_optional(aPath) : std::nullopt;
903 :
904 5207 : return AddStatusInternal(aPath, StatusIB(status.GetStatusCode()));
905 : }
906 :
907 : } // namespace app
908 : } // namespace chip
|
