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 : * @file
20 : * This file defines EventDataIB parser and builder in CHIP interaction model
21 : *
22 : */
23 :
24 : #include "EventDataIB.h"
25 :
26 : #include "MessageDefHelper.h"
27 :
28 : #include <inttypes.h>
29 : #include <stdarg.h>
30 : #include <stdio.h>
31 :
32 : #include <app/AppConfig.h>
33 :
34 : namespace chip {
35 : namespace app {
36 : #if CHIP_CONFIG_IM_PRETTY_PRINT
37 1579 : CHIP_ERROR EventDataIB::Parser::PrettyPrint() const
38 : {
39 1579 : CHIP_ERROR err = CHIP_NO_ERROR;
40 1579 : TLV::TLVReader reader;
41 :
42 1579 : PRETTY_PRINT("EventDataIB =");
43 1579 : PRETTY_PRINT("{");
44 :
45 : // make a copy of the Path reader
46 1579 : reader.Init(mReader);
47 :
48 9486 : while (CHIP_NO_ERROR == (err = reader.Next()))
49 : {
50 7907 : if (!TLV::IsContextTag(reader.GetTag()))
51 : {
52 0 : continue;
53 : }
54 7907 : uint32_t tagNum = TLV::TagNumFromTag(reader.GetTag());
55 7907 : switch (tagNum)
56 : {
57 1579 : case to_underlying(Tag::kPath): {
58 1579 : EventPathIB::Parser path;
59 1579 : ReturnErrorOnFailure(path.Init(reader));
60 :
61 1579 : PRETTY_PRINT_INCDEPTH();
62 1579 : ReturnErrorOnFailure(path.PrettyPrint());
63 1579 : PRETTY_PRINT_DECDEPTH();
64 : }
65 1579 : break;
66 1579 : case to_underlying(Tag::kEventNumber):
67 1579 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
68 :
69 : #if CHIP_DETAIL_LOGGING
70 : {
71 : EventNumber number;
72 1579 : ReturnErrorOnFailure(reader.Get(number));
73 1579 : PRETTY_PRINT("\tEventNumber = 0x" ChipLogFormatX64 ",", ChipLogValueX64(number));
74 : }
75 : #endif // CHIP_DETAIL_LOGGING
76 1579 : break;
77 1579 : case to_underlying(Tag::kPriority):
78 1579 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
79 :
80 : #if CHIP_DETAIL_LOGGING
81 : {
82 : uint64_t value;
83 1579 : ReturnErrorOnFailure(reader.Get(value));
84 1579 : PRETTY_PRINT("\tPriorityLevel = 0x" ChipLogFormatX64 ",", ChipLogValueX64(value));
85 : }
86 : #endif // CHIP_DETAIL_LOGGING
87 1579 : break;
88 1579 : case to_underlying(Tag::kEpochTimestamp):
89 1579 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
90 :
91 : #if CHIP_DETAIL_LOGGING
92 : {
93 : uint64_t value;
94 1579 : ReturnErrorOnFailure(reader.Get(value));
95 1579 : PRETTY_PRINT("\tEpochTimestamp = 0x" ChipLogFormatX64 ",", ChipLogValueX64(value));
96 : }
97 : #endif // CHIP_DETAIL_LOGGING
98 1579 : break;
99 :
100 4 : case to_underlying(Tag::kSystemTimestamp):
101 4 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
102 :
103 : #if CHIP_DETAIL_LOGGING
104 : {
105 : uint64_t value;
106 4 : ReturnErrorOnFailure(reader.Get(value));
107 4 : PRETTY_PRINT("\tSystemTimestamp = 0x" ChipLogFormatX64 ",", ChipLogValueX64(value));
108 : }
109 : #endif // CHIP_DETAIL_LOGGING
110 4 : break;
111 4 : case to_underlying(Tag::kDeltaEpochTimestamp):
112 4 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
113 :
114 : #if CHIP_DETAIL_LOGGING
115 : {
116 : uint64_t value;
117 4 : ReturnErrorOnFailure(reader.Get(value));
118 4 : PRETTY_PRINT("\tDeltaEpochTimestampstamp= 0x" ChipLogFormatX64 ",", ChipLogValueX64(value));
119 : }
120 : #endif // CHIP_DETAIL_LOGGING
121 4 : break;
122 4 : case to_underlying(Tag::kDeltaSystemTimestamp):
123 4 : VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
124 :
125 : #if CHIP_DETAIL_LOGGING
126 : {
127 : uint64_t value;
128 4 : ReturnErrorOnFailure(reader.Get(value));
129 4 : PRETTY_PRINT("\tDeltaSystemTimestamp = 0x" ChipLogFormatX64 ",", ChipLogValueX64(value));
130 : }
131 : #endif // CHIP_DETAIL_LOGGING
132 4 : break;
133 1579 : case to_underlying(Tag::kData):
134 1579 : PRETTY_PRINT_INCDEPTH();
135 1579 : ReturnErrorOnFailure(CheckIMPayload(reader, 0, "EventData"));
136 1579 : PRETTY_PRINT_DECDEPTH();
137 1579 : break;
138 0 : default:
139 0 : PRETTY_PRINT("Unknown tag num %" PRIu32, tagNum);
140 0 : break;
141 : }
142 : }
143 1579 : PRETTY_PRINT("},");
144 1579 : PRETTY_PRINT_BLANK_LINE();
145 :
146 : // if we have exhausted this container
147 1579 : if (CHIP_END_OF_TLV == err)
148 : {
149 1579 : err = CHIP_NO_ERROR;
150 : }
151 1579 : ReturnErrorOnFailure(err);
152 1579 : return reader.ExitContainer(mOuterContainerType);
153 : }
154 : #endif // CHIP_CONFIG_IM_PRETTY_PRINT
155 :
156 1576 : CHIP_ERROR EventDataIB::Parser::GetPath(EventPathIB::Parser * const apPath)
157 : {
158 1576 : TLV::TLVReader reader;
159 1576 : ReturnErrorOnFailure(mReader.FindElementWithTag(TLV::ContextTag(Tag::kPath), reader));
160 1576 : ReturnErrorOnFailure(apPath->Init(reader));
161 1576 : return CHIP_NO_ERROR;
162 : }
163 :
164 1576 : CHIP_ERROR EventDataIB::Parser::GetPriority(uint8_t * const apPriority)
165 : {
166 1576 : return GetUnsignedInteger(to_underlying(Tag::kPriority), apPriority);
167 : }
168 :
169 1576 : CHIP_ERROR EventDataIB::Parser::GetEventNumber(EventNumber * const apEventNumber)
170 : {
171 1576 : return GetUnsignedInteger(to_underlying(Tag::kEventNumber), apEventNumber);
172 : }
173 :
174 1576 : CHIP_ERROR EventDataIB::Parser::GetEpochTimestamp(uint64_t * const apEpochTimestamp)
175 : {
176 1576 : return GetUnsignedInteger(to_underlying(Tag::kEpochTimestamp), apEpochTimestamp);
177 : }
178 :
179 1576 : CHIP_ERROR EventDataIB::Parser::GetSystemTimestamp(uint64_t * const apSystemTimestamp)
180 : {
181 1576 : return GetUnsignedInteger(to_underlying(Tag::kSystemTimestamp), apSystemTimestamp);
182 : }
183 :
184 1576 : CHIP_ERROR EventDataIB::Parser::GetDeltaEpochTimestamp(uint64_t * const apDeltaEpochTimestampstamp)
185 : {
186 1576 : return GetUnsignedInteger(to_underlying(Tag::kDeltaEpochTimestamp), apDeltaEpochTimestampstamp);
187 : }
188 :
189 1576 : CHIP_ERROR EventDataIB::Parser::GetDeltaSystemTimestamp(uint64_t * const apDeltaSystemTimestamp)
190 : {
191 1576 : return GetUnsignedInteger(to_underlying(Tag::kDeltaSystemTimestamp), apDeltaSystemTimestamp);
192 : }
193 :
194 1576 : CHIP_ERROR EventDataIB::Parser::GetData(TLV::TLVReader * const apReader) const
195 : {
196 1576 : return mReader.FindElementWithTag(TLV::ContextTag(Tag::kData), *apReader);
197 : }
198 :
199 1575 : CHIP_ERROR EventDataIB::Parser::ProcessEventPath(EventPathIB::Parser & aEventPath, ConcreteEventPath & aConcreteEventPath)
200 : {
201 : // The ReportData must contain a concrete event path
202 1575 : CHIP_ERROR err = aEventPath.GetEndpoint(&(aConcreteEventPath.mEndpointId));
203 1575 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
204 :
205 1575 : err = aEventPath.GetCluster(&(aConcreteEventPath.mClusterId));
206 1575 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
207 :
208 1575 : err = aEventPath.GetEvent(&(aConcreteEventPath.mEventId));
209 1575 : VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB);
210 :
211 1575 : return CHIP_NO_ERROR;
212 : }
213 :
214 1575 : CHIP_ERROR EventDataIB::Parser::ProcessEventTimestamp(EventHeader & aEventHeader)
215 : {
216 1575 : CHIP_ERROR err = CHIP_NO_ERROR;
217 1575 : uint64_t timeStampVal = 0;
218 1575 : bool hasSystemTimestamp = false;
219 1575 : bool hasEpochTimestamp = false;
220 1575 : bool hasDeltaSystemTimestamp = false;
221 1575 : bool hasDeltaEpochTimestamp = false;
222 :
223 1575 : err = GetDeltaSystemTimestamp(&timeStampVal);
224 1575 : if (err == CHIP_END_OF_TLV)
225 : {
226 1575 : err = CHIP_NO_ERROR;
227 : }
228 0 : else if (err == CHIP_NO_ERROR)
229 : {
230 0 : VerifyOrReturnError(aEventHeader.mTimestamp.IsSystem(), CHIP_ERROR_IM_MALFORMED_EVENT_DATA_IB);
231 0 : aEventHeader.mTimestamp.mValue += timeStampVal;
232 0 : hasDeltaSystemTimestamp = true;
233 : }
234 1575 : ReturnErrorOnFailure(err);
235 :
236 1575 : err = GetDeltaEpochTimestamp(&timeStampVal);
237 1575 : if (err == CHIP_END_OF_TLV)
238 : {
239 1575 : err = CHIP_NO_ERROR;
240 : }
241 0 : else if (err == CHIP_NO_ERROR)
242 : {
243 0 : VerifyOrReturnError(aEventHeader.mTimestamp.IsEpoch(), CHIP_ERROR_IM_MALFORMED_EVENT_DATA_IB);
244 0 : aEventHeader.mTimestamp.mValue += timeStampVal;
245 0 : hasDeltaEpochTimestamp = true;
246 : }
247 1575 : ReturnErrorOnFailure(err);
248 :
249 1575 : err = GetSystemTimestamp(&timeStampVal);
250 1575 : if (err == CHIP_END_OF_TLV)
251 : {
252 1575 : err = CHIP_NO_ERROR;
253 : }
254 0 : else if (err == CHIP_NO_ERROR)
255 : {
256 0 : aEventHeader.mTimestamp.mType = Timestamp::Type::kSystem;
257 0 : aEventHeader.mTimestamp.mValue = timeStampVal;
258 0 : hasSystemTimestamp = true;
259 : }
260 1575 : ReturnErrorOnFailure(err);
261 :
262 1575 : err = GetEpochTimestamp(&timeStampVal);
263 1575 : if (err == CHIP_END_OF_TLV)
264 : {
265 0 : err = CHIP_NO_ERROR;
266 : }
267 1575 : else if (err == CHIP_NO_ERROR)
268 : {
269 1575 : aEventHeader.mTimestamp.mType = Timestamp::Type::kEpoch;
270 1575 : aEventHeader.mTimestamp.mValue = timeStampVal;
271 1575 : hasEpochTimestamp = true;
272 : }
273 :
274 1575 : if (hasSystemTimestamp + hasEpochTimestamp + hasDeltaSystemTimestamp + hasDeltaEpochTimestamp == 1)
275 : {
276 1575 : return CHIP_NO_ERROR;
277 : }
278 0 : return CHIP_ERROR_IM_MALFORMED_EVENT_DATA_IB;
279 : }
280 :
281 1575 : CHIP_ERROR EventDataIB::Parser::DecodeEventHeader(EventHeader & aEventHeader)
282 : {
283 1575 : uint8_t priorityLevel = 0;
284 1575 : EventPathIB::Parser path;
285 1575 : ReturnErrorOnFailure(GetPath(&path));
286 1575 : ReturnErrorOnFailure(ProcessEventPath(path, aEventHeader.mPath));
287 1575 : ReturnErrorOnFailure(GetEventNumber(&(aEventHeader.mEventNumber)));
288 1575 : ReturnErrorOnFailure(GetPriority(&priorityLevel));
289 1575 : aEventHeader.mPriorityLevel = static_cast<PriorityLevel>(priorityLevel);
290 1575 : ReturnErrorOnFailure(ProcessEventTimestamp(aEventHeader));
291 1575 : return CHIP_NO_ERROR;
292 : }
293 :
294 1328 : EventPathIB::Builder & EventDataIB::Builder::CreatePath()
295 : {
296 : // skip if error has already been set
297 1328 : if (mError == CHIP_NO_ERROR)
298 : {
299 1328 : mError = mPath.Init(mpWriter, to_underlying(Tag::kPath));
300 : }
301 1328 : return mPath;
302 : }
303 :
304 1328 : EventDataIB::Builder & EventDataIB::Builder::Priority(const uint8_t aPriority)
305 : {
306 : // skip if error has already been set
307 1328 : if (mError == CHIP_NO_ERROR)
308 : {
309 1328 : mError = mpWriter->Put(TLV::ContextTag(Tag::kPriority), aPriority);
310 : }
311 1328 : return *this;
312 : }
313 :
314 1328 : EventDataIB::Builder & EventDataIB::Builder::EventNumber(const uint64_t aEventNumber)
315 : {
316 : // skip if error has already been set
317 1328 : if (mError == CHIP_NO_ERROR)
318 : {
319 1328 : mError = mpWriter->Put(TLV::ContextTag(Tag::kEventNumber), aEventNumber);
320 : }
321 1328 : return *this;
322 : }
323 :
324 1304 : EventDataIB::Builder & EventDataIB::Builder::EpochTimestamp(const uint64_t aEpochTimestamp)
325 : {
326 : // skip if error has already been set
327 1304 : if (mError == CHIP_NO_ERROR)
328 : {
329 1304 : mError = mpWriter->Put(TLV::ContextTag(Tag::kEpochTimestamp), aEpochTimestamp);
330 : }
331 1304 : return *this;
332 : }
333 :
334 28 : EventDataIB::Builder & EventDataIB::Builder::SystemTimestamp(const uint64_t aSystemTimestamp)
335 : {
336 : // skip if error has already been set
337 28 : if (mError == CHIP_NO_ERROR)
338 : {
339 28 : mError = mpWriter->Put(TLV::ContextTag(Tag::kSystemTimestamp), aSystemTimestamp);
340 : }
341 28 : return *this;
342 : }
343 :
344 4 : EventDataIB::Builder & EventDataIB::Builder::DeltaEpochTimestamp(const uint64_t aDeltaEpochTimestamp)
345 : {
346 : // skip if error has already been set
347 4 : if (mError == CHIP_NO_ERROR)
348 : {
349 4 : mError = mpWriter->Put(TLV::ContextTag(Tag::kDeltaEpochTimestamp), aDeltaEpochTimestamp);
350 : }
351 4 : return *this;
352 : }
353 :
354 4 : EventDataIB::Builder & EventDataIB::Builder::DeltaSystemTimestamp(const uint64_t aDeltaSystemTimestamp)
355 : {
356 : // skip if error has already been set
357 4 : if (mError == CHIP_NO_ERROR)
358 : {
359 4 : mError = mpWriter->Put(TLV::ContextTag(Tag::kDeltaSystemTimestamp), aDeltaSystemTimestamp);
360 : }
361 4 : return *this;
362 : }
363 :
364 : // Mark the end of this element and recover the type for outer container
365 1328 : CHIP_ERROR EventDataIB::Builder::EndOfEventDataIB()
366 : {
367 1328 : EndOfContainer();
368 1328 : return GetError();
369 : }
370 : } // namespace app
371 : } // namespace chip
|
