Line data Source code
1 : /**
2 : *
3 : * Copyright (c) 2020 Project CHIP Authors
4 : * Copyright (c) 2018 Google LLC.
5 : * Copyright (c) 2016-2017 Nest Labs, Inc.
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 "EventPathIB.h"
20 :
21 : #include "MessageDefHelper.h"
22 :
23 : #include <inttypes.h>
24 : #include <stdarg.h>
25 : #include <stdio.h>
26 :
27 : #include <app/AppConfig.h>
28 :
29 : #include <protocols/interaction_model/Constants.h>
30 :
31 : namespace chip {
32 : namespace app {
33 : #if CHIP_CONFIG_IM_PRETTY_PRINT
34 2091 : CHIP_ERROR EventPathIB::Parser::PrettyPrint() const
35 : {
36 2091 : CHIP_ERROR err = CHIP_NO_ERROR;
37 2091 : TLV::TLVReader reader;
38 :
39 2091 : PRETTY_PRINT("EventPath =");
40 2091 : PRETTY_PRINT("{");
41 :
42 : // make a copy of the Path reader
43 2091 : reader.Init(mReader);
44 :
45 8067 : while (CHIP_NO_ERROR == (err = reader.Next()))
46 : {
47 5976 : if (!TLV::IsContextTag(reader.GetTag()))
48 : {
49 0 : continue;
50 : }
51 5976 : uint32_t tagNum = TLV::TagNumFromTag(reader.GetTag());
52 5976 : switch (tagNum)
53 : {
54 9 : case to_underlying(Tag::kNode):
55 9 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
56 : #if CHIP_DETAIL_LOGGING
57 : {
58 : NodeId node;
59 9 : reader.Get(node);
60 9 : PRETTY_PRINT("\tNode = 0x" ChipLogFormatX64 ",", ChipLogValueX64(node));
61 : }
62 : #endif // CHIP_DETAIL_LOGGING
63 9 : break;
64 2091 : case to_underlying(Tag::kEndpoint):
65 2091 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
66 : #if CHIP_DETAIL_LOGGING
67 : {
68 : EndpointId endpoint;
69 2091 : reader.Get(endpoint);
70 2091 : PRETTY_PRINT("\tEndpoint = 0x%x,", endpoint);
71 : }
72 : #endif // CHIP_DETAIL_LOGGING
73 2091 : break;
74 2090 : case to_underlying(Tag::kCluster):
75 2090 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
76 :
77 : #if CHIP_DETAIL_LOGGING
78 : {
79 : ClusterId cluster;
80 2090 : reader.Get(cluster);
81 2090 : PRETTY_PRINT("\tCluster = 0x%" PRIx32 ",", cluster);
82 : }
83 : #endif // CHIP_DETAIL_LOGGING
84 2090 : break;
85 1773 : case to_underlying(Tag::kEvent):
86 1773 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
87 :
88 : #if CHIP_DETAIL_LOGGING
89 : {
90 : EventId event;
91 1773 : reader.Get(event);
92 1773 : PRETTY_PRINT("\tEvent = 0x%" PRIx32 ",", event);
93 : }
94 : #endif // CHIP_DETAIL_LOGGING
95 1773 : break;
96 13 : case to_underlying(Tag::kIsUrgent):
97 13 : VerifyOrReturnError(TLV::kTLVType_Boolean == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
98 :
99 : #if CHIP_DETAIL_LOGGING
100 : {
101 : bool isUrgent;
102 13 : ReturnErrorOnFailure(reader.Get(isUrgent));
103 13 : PRETTY_PRINT("\tisUrgent = %s, ", isUrgent ? "true" : "false");
104 : }
105 : #endif // CHIP_DETAIL_LOGGING
106 13 : break;
107 0 : default:
108 0 : PRETTY_PRINT("Unknown tag num %" PRIu32, tagNum);
109 0 : break;
110 : }
111 : }
112 :
113 2091 : PRETTY_PRINT("},");
114 2091 : PRETTY_PRINT_BLANK_LINE();
115 :
116 : // if we have exhausted this container
117 2091 : if (CHIP_END_OF_TLV == err)
118 : {
119 2091 : err = CHIP_NO_ERROR;
120 : }
121 :
122 2091 : ReturnErrorOnFailure(err);
123 2091 : return reader.ExitContainer(mOuterContainerType);
124 : }
125 : #endif // CHIP_CONFIG_IM_PRETTY_PRINT
126 :
127 1 : CHIP_ERROR EventPathIB::Parser::GetNode(NodeId * const apNode) const
128 : {
129 1 : return GetUnsignedInteger(to_underlying(Tag::kNode), apNode);
130 : }
131 :
132 6459 : CHIP_ERROR EventPathIB::Parser::GetEndpoint(EndpointId * const apEndpoint) const
133 : {
134 6459 : return GetUnsignedInteger(to_underlying(Tag::kEndpoint), apEndpoint);
135 : }
136 :
137 6459 : CHIP_ERROR EventPathIB::Parser::GetCluster(ClusterId * const apCluster) const
138 : {
139 6459 : return GetUnsignedInteger(to_underlying(Tag::kCluster), apCluster);
140 : }
141 :
142 6459 : CHIP_ERROR EventPathIB::Parser::GetEvent(EventId * const apEvent) const
143 : {
144 6459 : return GetUnsignedInteger(to_underlying(Tag::kEvent), apEvent);
145 : }
146 :
147 4 : CHIP_ERROR EventPathIB::Parser::GetEventPath(ConcreteEventPath * const apPath) const
148 : {
149 4 : VerifyOrReturnError(GetEndpoint(&(apPath->mEndpointId)) == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
150 4 : VerifyOrReturnError(GetCluster(&(apPath->mClusterId)) == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
151 4 : VerifyOrReturnError(GetEvent(&(apPath->mEventId)) == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
152 4 : return CHIP_NO_ERROR;
153 : }
154 :
155 532 : CHIP_ERROR EventPathIB::Parser::GetIsUrgent(bool * const apIsUrgent) const
156 : {
157 532 : return GetSimpleValue(to_underlying(Tag::kIsUrgent), TLV::kTLVType_Boolean, apIsUrgent);
158 : }
159 :
160 531 : CHIP_ERROR EventPathIB::Parser::ParsePath(EventPathParams & aEvent) const
161 : {
162 531 : CHIP_ERROR err = GetEndpoint(&(aEvent.mEndpointId));
163 531 : if (err == CHIP_NO_ERROR)
164 : {
165 531 : VerifyOrReturnError(!aEvent.HasWildcardEndpointId(), CHIP_IM_GLOBAL_STATUS(InvalidAction));
166 : }
167 0 : else if (err == CHIP_END_OF_TLV)
168 : {
169 0 : err = CHIP_NO_ERROR;
170 : }
171 531 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_IM_GLOBAL_STATUS(InvalidAction));
172 :
173 531 : err = GetCluster(&(aEvent.mClusterId));
174 531 : if (err == CHIP_NO_ERROR)
175 : {
176 530 : VerifyOrReturnError(!aEvent.HasWildcardClusterId(), CHIP_IM_GLOBAL_STATUS(InvalidAction));
177 : }
178 1 : else if (err == CHIP_END_OF_TLV)
179 : {
180 1 : err = CHIP_NO_ERROR;
181 : }
182 531 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_IM_GLOBAL_STATUS(InvalidAction));
183 :
184 531 : err = GetEvent(&(aEvent.mEventId));
185 531 : if (CHIP_END_OF_TLV == err)
186 : {
187 324 : err = CHIP_NO_ERROR;
188 : }
189 207 : else if (err == CHIP_NO_ERROR)
190 : {
191 207 : VerifyOrReturnError(!aEvent.HasWildcardEventId(), CHIP_IM_GLOBAL_STATUS(InvalidAction));
192 : }
193 531 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_IM_GLOBAL_STATUS(InvalidAction));
194 :
195 531 : err = GetIsUrgent(&(aEvent.mIsUrgentEvent));
196 531 : if (CHIP_END_OF_TLV == err)
197 : {
198 523 : err = CHIP_NO_ERROR;
199 : }
200 531 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_IM_GLOBAL_STATUS(InvalidAction));
201 531 : return CHIP_NO_ERROR;
202 : }
203 :
204 9 : EventPathIB::Builder & EventPathIB::Builder::Node(const NodeId aNode)
205 : {
206 : // skip if error has already been set
207 9 : if (mError == CHIP_NO_ERROR)
208 : {
209 9 : mError = mpWriter->Put(TLV::ContextTag(Tag::kNode), aNode);
210 : }
211 9 : return *this;
212 : }
213 :
214 1848 : EventPathIB::Builder & EventPathIB::Builder::Endpoint(const EndpointId aEndpoint)
215 : {
216 : // skip if error has already been set
217 1848 : if (mError == CHIP_NO_ERROR)
218 : {
219 1848 : mError = mpWriter->Put(TLV::ContextTag(Tag::kEndpoint), aEndpoint);
220 : }
221 1848 : return *this;
222 : }
223 :
224 1847 : EventPathIB::Builder & EventPathIB::Builder::Cluster(const ClusterId aCluster)
225 : {
226 : // skip if error has already been set
227 1847 : if (mError == CHIP_NO_ERROR)
228 : {
229 1847 : mError = mpWriter->Put(TLV::ContextTag(Tag::kCluster), aCluster);
230 : }
231 1847 : return *this;
232 : }
233 :
234 1530 : EventPathIB::Builder & EventPathIB::Builder::Event(const EventId aEvent)
235 : {
236 : // skip if error has already been set
237 1530 : if (mError == CHIP_NO_ERROR)
238 : {
239 1530 : mError = mpWriter->Put(TLV::ContextTag(Tag::kEvent), aEvent);
240 : }
241 1530 : return *this;
242 : }
243 :
244 13 : EventPathIB::Builder & EventPathIB::Builder::IsUrgent(const bool aIsUrgent)
245 : {
246 : // skip if error has already been set
247 13 : if (mError == CHIP_NO_ERROR)
248 : {
249 13 : mError = mpWriter->PutBoolean(TLV::ContextTag(Tag::kIsUrgent), aIsUrgent);
250 : }
251 13 : return *this;
252 : }
253 :
254 1848 : CHIP_ERROR EventPathIB::Builder::EndOfEventPathIB()
255 : {
256 1848 : EndOfContainer();
257 1848 : return GetError();
258 : }
259 :
260 511 : CHIP_ERROR EventPathIB::Builder::Encode(const EventPathParams & aEventPathParams)
261 : {
262 511 : if (!(aEventPathParams.HasWildcardEndpointId()))
263 : {
264 511 : Endpoint(aEventPathParams.mEndpointId);
265 : }
266 :
267 511 : if (!(aEventPathParams.HasWildcardClusterId()))
268 : {
269 510 : Cluster(aEventPathParams.mClusterId);
270 : }
271 :
272 511 : if (!(aEventPathParams.HasWildcardEventId()))
273 : {
274 193 : Event(aEventPathParams.mEventId);
275 : }
276 :
277 511 : if (aEventPathParams.mIsUrgentEvent)
278 : {
279 4 : IsUrgent(aEventPathParams.mIsUrgentEvent);
280 : }
281 511 : return EndOfEventPathIB();
282 : }
283 : } // namespace app
284 : } // namespace chip
|
