Line data Source code
1 : /*
2 : * Copyright (c) 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 : #include <data-model-providers/codegen/CodegenDataModelProvider.h>
18 :
19 : #include <optional>
20 : #include <variant>
21 :
22 : #include <access/AccessControl.h>
23 : #include <access/Privilege.h>
24 : #include <access/RequestPath.h>
25 : #include <app-common/zap-generated/attribute-type.h>
26 : #include <app/AttributeAccessInterface.h>
27 : #include <app/AttributeAccessInterfaceRegistry.h>
28 : #include <app/AttributeValueEncoder.h>
29 : #include <app/RequiredPrivilege.h>
30 : #include <app/data-model/FabricScoped.h>
31 : #include <app/util/af-types.h>
32 : #include <app/util/attribute-metadata.h>
33 : #include <app/util/attribute-storage-detail.h>
34 : #include <app/util/attribute-storage-null-handling.h>
35 : #include <app/util/attribute-storage.h>
36 : #include <app/util/ember-io-storage.h>
37 : #include <app/util/endpoint-config-api.h>
38 : #include <app/util/odd-sized-integers.h>
39 : #include <data-model-providers/codegen/EmberAttributeDataBuffer.h>
40 : #include <data-model-providers/codegen/EmberMetadata.h>
41 : #include <lib/core/CHIPError.h>
42 : #include <lib/support/CodeUtils.h>
43 : #include <lib/support/Span.h>
44 :
45 : #include <zap-generated/endpoint_config.h>
46 :
47 : namespace chip {
48 : namespace app {
49 :
50 : namespace {
51 :
52 : using namespace chip::app::Compatibility::Internal;
53 : using Protocols::InteractionModel::Status;
54 :
55 : /// Attempts to read via an attribute access interface (AAI)
56 : ///
57 : /// If it returns a CHIP_ERROR, then this is a FINAL result (i.e. either failure or success).
58 : ///
59 : /// If it returns std::nullopt, then there is no AAI to handle the given path
60 : /// and processing should figure out the value otherwise (generally from other ember data)
61 1801 : std::optional<CHIP_ERROR> TryReadViaAccessInterface(const ConcreteAttributePath & path, AttributeAccessInterface * aai,
62 : AttributeValueEncoder & encoder)
63 : {
64 : // Processing can happen only if an attribute access interface actually exists..
65 1801 : if (aai == nullptr)
66 : {
67 39 : return std::nullopt;
68 : }
69 :
70 1762 : CHIP_ERROR err = aai->Read(path, encoder);
71 :
72 1762 : if (err != CHIP_NO_ERROR)
73 : {
74 : // Implementation of 8.4.3.2 of the spec for path expansion
75 138 : if (path.mExpanded && (err == CHIP_IM_GLOBAL_STATUS(UnsupportedRead)))
76 : {
77 1 : return CHIP_NO_ERROR;
78 : }
79 :
80 137 : return err;
81 : }
82 :
83 : // If the encoder tried to encode, then a value should have been written.
84 : // - if encode, assume DONE (i.e. FINAL CHIP_NO_ERROR)
85 : // - if no encode, say that processing must continue
86 3248 : return encoder.TriedEncode() ? std::make_optional(CHIP_NO_ERROR) : std::nullopt;
87 : }
88 :
89 : } // namespace
90 :
91 : /// separated-out ReadAttribute implementation (given existing complexity)
92 : ///
93 : /// Generally will:
94 : /// - validate ACL (only for non-internal requests)
95 : /// - Try to read attribute via the AttributeAccessInterface
96 : /// - Try to read the value from ember RAM storage
97 1807 : DataModel::ActionReturnStatus CodegenDataModelProvider::ReadAttribute(const DataModel::ReadAttributeRequest & request,
98 : AttributeValueEncoder & encoder)
99 : {
100 1807 : ChipLogDetail(DataManagement,
101 : "Reading attribute: Cluster=" ChipLogFormatMEI " Endpoint=0x%x AttributeId=" ChipLogFormatMEI " (expanded=%d)",
102 : ChipLogValueMEI(request.path.mClusterId), request.path.mEndpointId, ChipLogValueMEI(request.path.mAttributeId),
103 : request.path.mExpanded);
104 :
105 1807 : if (auto * cluster = mRegistry.Get(request.path); cluster != nullptr)
106 : {
107 1 : return cluster->ReadAttribute(request, encoder);
108 : }
109 :
110 1806 : auto metadata = Ember::FindAttributeMetadata(request.path);
111 :
112 : // Explicit failure in finding a suitable metadata
113 1806 : if (const Status * status = std::get_if<Status>(&metadata))
114 : {
115 5 : VerifyOrDie((*status == Status::UnsupportedEndpoint) || //
116 : (*status == Status::UnsupportedCluster) || //
117 : (*status == Status::UnsupportedAttribute));
118 5 : return *status;
119 : }
120 :
121 : // Read via AAI
122 3602 : std::optional<CHIP_ERROR> aai_result = TryReadViaAccessInterface(
123 1801 : request.path, AttributeAccessInterfaceRegistry::Instance().Get(request.path.mEndpointId, request.path.mClusterId), encoder);
124 1801 : VerifyOrReturnError(!aai_result.has_value(), *aai_result);
125 :
126 39 : const EmberAfAttributeMetadata * attributeMetadata = std::get<const EmberAfAttributeMetadata *>(metadata);
127 : // We can only get a status or metadata.
128 39 : VerifyOrDie(attributeMetadata != nullptr);
129 :
130 : // At this point, we have to use ember directly to read the data.
131 : EmberAfAttributeSearchRecord record;
132 39 : record.endpoint = request.path.mEndpointId;
133 39 : record.clusterId = request.path.mClusterId;
134 39 : record.attributeId = request.path.mAttributeId;
135 39 : Protocols::InteractionModel::Status status = emAfReadOrWriteAttribute(
136 39 : &record, &attributeMetadata, gEmberAttributeIOBufferSpan.data(), static_cast<uint16_t>(gEmberAttributeIOBufferSpan.size()),
137 : /* write = */ false);
138 :
139 39 : if (status != Protocols::InteractionModel::Status::Success)
140 : {
141 2 : return CHIP_ERROR_IM_GLOBAL_STATUS_VALUE(status);
142 : }
143 :
144 37 : VerifyOrReturnError(attributeMetadata != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
145 :
146 37 : MutableByteSpan data = gEmberAttributeIOBufferSpan;
147 37 : Ember::EmberAttributeDataBuffer emberData(attributeMetadata, data);
148 37 : return encoder.Encode(emberData);
149 : }
150 :
151 : } // namespace app
152 : } // namespace chip
|
