xref: /aosp_15_r20/external/ot-br-posix/src/dbus/common/dbus_message_helper_openthread.cpp (revision 4a64e381480ef79f0532b2421e44e6ee336b8e0d)
1 /*
2  *    Copyright (c) 2020, The OpenThread Authors.
3  *    All rights reserved.
4  *
5  *    Redistribution and use in source and binary forms, with or without
6  *    modification, are permitted provided that the following conditions are met:
7  *    1. Redistributions of source code must retain the above copyright
8  *       notice, this list of conditions and the following disclaimer.
9  *    2. Redistributions in binary form must reproduce the above copyright
10  *       notice, this list of conditions and the following disclaimer in the
11  *       documentation and/or other materials provided with the distribution.
12  *    3. Neither the name of the copyright holder nor the
13  *       names of its contributors may be used to endorse or promote products
14  *       derived from this software without specific prior written permission.
15  *
16  *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  *    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  *    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  *    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  *    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  *    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  *    POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <string.h>
30 
31 #include "dbus/common/dbus_message_helper.hpp"
32 
33 namespace otbr {
34 namespace DBus {
35 
DBusMessageExtract(DBusMessageIter * aIter,otbrError & aError)36 otbrError DBusMessageExtract(DBusMessageIter *aIter, otbrError &aError)
37 {
38     uint8_t   val;
39     otbrError error = DBusMessageExtract(aIter, val);
40 
41     VerifyOrExit(error == OTBR_ERROR_NONE);
42     aError = static_cast<otbrError>(val);
43 exit:
44     return error;
45 }
46 
DBusMessageEncode(DBusMessageIter * aIter,const otbrError & aError)47 otbrError DBusMessageEncode(DBusMessageIter *aIter, const otbrError &aError)
48 {
49     return DBusMessageEncode(aIter, static_cast<uint8_t>(aError));
50 }
51 
DBusMessageExtract(DBusMessageIter * aIter,ActiveScanResult & aScanResult)52 otbrError DBusMessageExtract(DBusMessageIter *aIter, ActiveScanResult &aScanResult)
53 {
54     DBusMessageIter sub;
55     otbrError       error = OTBR_ERROR_NONE;
56 
57     // Local variable to help convert an RSSI value.
58     // Dbus doesn't have the concept of a signed byte
59     int16_t rssi = 0;
60 
61     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
62 
63     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mExtAddress));
64     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mNetworkName));
65     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mExtendedPanId));
66     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mSteeringData));
67     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mPanId));
68     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mJoinerUdpPort));
69     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mChannel));
70     SuccessOrExit(error = DBusMessageExtract<int16_t>(&sub, rssi));
71     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mLqi));
72     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mVersion));
73     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mIsNative));
74     SuccessOrExit(error = DBusMessageExtract(&sub, aScanResult.mDiscover));
75 
76     // Double check the value is within int8 bounds and cast back
77     VerifyOrExit((rssi <= INT8_MAX) && (rssi >= INT8_MIN), error = OTBR_ERROR_PARSE);
78     aScanResult.mRssi = static_cast<int8_t>(rssi);
79 
80     dbus_message_iter_next(aIter);
81     error = OTBR_ERROR_NONE;
82 exit:
83     return error;
84 }
85 
DBusMessageEncode(DBusMessageIter * aIter,const ActiveScanResult & aScanResult)86 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ActiveScanResult &aScanResult)
87 {
88     DBusMessageIter sub;
89     otbrError       error = OTBR_ERROR_NONE;
90 
91     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
92     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mExtAddress));
93     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mNetworkName));
94     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mExtendedPanId));
95     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mSteeringData));
96     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mPanId));
97     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mJoinerUdpPort));
98     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mChannel));
99 
100     // Dbus doesn't have a signed byte, cast into an int16
101     SuccessOrExit(error = DBusMessageEncode(&sub, static_cast<int16_t>(aScanResult.mRssi)));
102 
103     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mLqi));
104     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mVersion));
105     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mIsNative));
106     SuccessOrExit(error = DBusMessageEncode(&sub, aScanResult.mDiscover));
107     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
108 
109     error = OTBR_ERROR_NONE;
110 exit:
111     return error;
112 }
113 
DBusMessageExtract(DBusMessageIter * aIter,EnergyScanResult & aResult)114 otbrError DBusMessageExtract(DBusMessageIter *aIter, EnergyScanResult &aResult)
115 {
116     DBusMessageIter sub;
117     otbrError       error = OTBR_ERROR_NONE;
118 
119     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
120 
121     SuccessOrExit(error = DBusMessageExtract(&sub, aResult.mChannel));
122     SuccessOrExit(error = DBusMessageExtract(&sub, aResult.mMaxRssi));
123 
124     dbus_message_iter_next(aIter);
125 exit:
126     return error;
127 }
128 
DBusMessageEncode(DBusMessageIter * aIter,const EnergyScanResult & aResult)129 otbrError DBusMessageEncode(DBusMessageIter *aIter, const EnergyScanResult &aResult)
130 {
131     DBusMessageIter sub;
132     otbrError       error = OTBR_ERROR_NONE;
133 
134     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
135 
136     SuccessOrExit(error = DBusMessageEncode(&sub, aResult.mChannel));
137     SuccessOrExit(error = DBusMessageEncode(&sub, aResult.mMaxRssi));
138 
139     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
140 
141 exit:
142     return error;
143 }
144 
DBusMessageEncode(DBusMessageIter * aIter,const LinkModeConfig & aConfig)145 otbrError DBusMessageEncode(DBusMessageIter *aIter, const LinkModeConfig &aConfig)
146 {
147     otbrError       error = OTBR_ERROR_NONE;
148     DBusMessageIter sub;
149 
150     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
151 
152     SuccessOrExit(error = DBusMessageEncode(&sub, aConfig.mRxOnWhenIdle));
153     SuccessOrExit(error = DBusMessageEncode(&sub, aConfig.mDeviceType));
154     SuccessOrExit(error = DBusMessageEncode(&sub, aConfig.mNetworkData));
155 
156     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
157     error = OTBR_ERROR_NONE;
158 exit:
159     return error;
160 }
161 
DBusMessageExtract(DBusMessageIter * aIter,LinkModeConfig & aConfig)162 otbrError DBusMessageExtract(DBusMessageIter *aIter, LinkModeConfig &aConfig)
163 {
164     otbrError       error = OTBR_ERROR_DBUS;
165     DBusMessageIter sub;
166 
167     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
168 
169     SuccessOrExit(DBusMessageExtract(&sub, aConfig.mRxOnWhenIdle));
170     SuccessOrExit(DBusMessageExtract(&sub, aConfig.mDeviceType));
171     SuccessOrExit(DBusMessageExtract(&sub, aConfig.mNetworkData));
172 
173     dbus_message_iter_next(aIter);
174     error = OTBR_ERROR_NONE;
175 exit:
176     return error;
177 }
178 
DBusMessageEncode(DBusMessageIter * aIter,const Ip6Prefix & aPrefix)179 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Ip6Prefix &aPrefix)
180 {
181     DBusMessageIter sub;
182     otbrError       error = OTBR_ERROR_NONE;
183 
184     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
185     VerifyOrExit(aPrefix.mPrefix.size() <= OTBR_IP6_PREFIX_SIZE, error = OTBR_ERROR_DBUS);
186 
187     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mPrefix));
188     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mLength));
189 
190     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
191 
192 exit:
193     return error;
194 }
195 
DBusMessageExtract(DBusMessageIter * aIter,Ip6Prefix & aPrefix)196 otbrError DBusMessageExtract(DBusMessageIter *aIter, Ip6Prefix &aPrefix)
197 {
198     DBusMessageIter sub;
199     otbrError       error = OTBR_ERROR_NONE;
200 
201     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
202     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mPrefix));
203     VerifyOrExit(aPrefix.mPrefix.size() <= OTBR_IP6_PREFIX_SIZE, error = OTBR_ERROR_DBUS);
204     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mLength));
205 
206     dbus_message_iter_next(aIter);
207 
208 exit:
209     return error;
210 }
211 
DBusMessageEncode(DBusMessageIter * aIter,const ExternalRoute & aRoute)212 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ExternalRoute &aRoute)
213 {
214     DBusMessageIter sub;
215     otbrError       error = OTBR_ERROR_NONE;
216 
217     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
218 
219     SuccessOrExit(error = DBusMessageEncode(&sub, aRoute.mPrefix));
220     SuccessOrExit(error = DBusMessageEncode(&sub, aRoute.mRloc16));
221     SuccessOrExit(error = DBusMessageEncode(&sub, aRoute.mPreference));
222     SuccessOrExit(error = DBusMessageEncode(&sub, aRoute.mStable));
223     SuccessOrExit(error = DBusMessageEncode(&sub, aRoute.mNextHopIsThisDevice));
224 
225     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
226 
227 exit:
228     return error;
229 }
230 
DBusMessageExtract(DBusMessageIter * aIter,ExternalRoute & aRoute)231 otbrError DBusMessageExtract(DBusMessageIter *aIter, ExternalRoute &aRoute)
232 {
233     DBusMessageIter sub;
234     otbrError       error = OTBR_ERROR_NONE;
235 
236     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
237     SuccessOrExit(error = DBusMessageExtract(&sub, aRoute.mPrefix));
238     SuccessOrExit(error = DBusMessageExtract(&sub, aRoute.mRloc16));
239     SuccessOrExit(error = DBusMessageExtract(&sub, aRoute.mPreference));
240     SuccessOrExit(error = DBusMessageExtract(&sub, aRoute.mStable));
241     SuccessOrExit(error = DBusMessageExtract(&sub, aRoute.mNextHopIsThisDevice));
242 
243     dbus_message_iter_next(aIter);
244 
245 exit:
246     return error;
247 }
248 
DBusMessageEncode(DBusMessageIter * aIter,const OnMeshPrefix & aPrefix)249 otbrError DBusMessageEncode(DBusMessageIter *aIter, const OnMeshPrefix &aPrefix)
250 {
251     DBusMessageIter sub;
252     otbrError       error = OTBR_ERROR_NONE;
253 
254     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
255 
256     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mPrefix));
257     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mRloc16));
258     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mPreference));
259 
260     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mPreferred));
261     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mSlaac));
262     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mDhcp));
263     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mConfigure));
264     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mDefaultRoute));
265     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mOnMesh));
266     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mStable));
267     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mNdDns));
268     SuccessOrExit(error = DBusMessageEncode(&sub, aPrefix.mDp));
269     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
270 
271 exit:
272     return error;
273 }
274 
DBusMessageExtract(DBusMessageIter * aIter,OnMeshPrefix & aPrefix)275 otbrError DBusMessageExtract(DBusMessageIter *aIter, OnMeshPrefix &aPrefix)
276 {
277     DBusMessageIter sub;
278     otbrError       error = OTBR_ERROR_NONE;
279 
280     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
281     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mPrefix));
282     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mRloc16));
283     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mPreference));
284     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mPreferred));
285     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mSlaac));
286     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mDhcp));
287     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mConfigure));
288     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mDefaultRoute));
289     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mOnMesh));
290     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mStable));
291     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mNdDns));
292     SuccessOrExit(error = DBusMessageExtract(&sub, aPrefix.mDp));
293 
294     dbus_message_iter_next(aIter);
295 
296 exit:
297     return error;
298 }
299 
DBusMessageEncode(DBusMessageIter * aIter,const MacCounters & aCounters)300 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MacCounters &aCounters)
301 {
302     auto args = std::tie(aCounters.mTxTotal, aCounters.mTxUnicast, aCounters.mTxBroadcast, aCounters.mTxAckRequested,
303                          aCounters.mTxAcked, aCounters.mTxNoAckRequested, aCounters.mTxData, aCounters.mTxDataPoll,
304                          aCounters.mTxBeacon, aCounters.mTxBeaconRequest, aCounters.mTxOther, aCounters.mTxRetry,
305                          aCounters.mTxErrCca, aCounters.mTxErrAbort, aCounters.mTxErrBusyChannel, aCounters.mRxTotal,
306                          aCounters.mRxUnicast, aCounters.mRxBroadcast, aCounters.mRxData, aCounters.mRxDataPoll,
307                          aCounters.mRxBeacon, aCounters.mRxBeaconRequest, aCounters.mRxOther,
308                          aCounters.mRxAddressFiltered, aCounters.mRxDestAddrFiltered, aCounters.mRxDuplicated,
309                          aCounters.mRxErrNoFrame, aCounters.mRxErrUnknownNeighbor, aCounters.mRxErrInvalidSrcAddr,
310                          aCounters.mRxErrSec, aCounters.mRxErrFcs, aCounters.mRxErrOther);
311     DBusMessageIter sub;
312     otbrError       error = OTBR_ERROR_NONE;
313 
314     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
315     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
316     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
317 exit:
318     return error;
319 }
320 
DBusMessageExtract(DBusMessageIter * aIter,MacCounters & aCounters)321 otbrError DBusMessageExtract(DBusMessageIter *aIter, MacCounters &aCounters)
322 {
323     auto args = std::tie(aCounters.mTxTotal, aCounters.mTxUnicast, aCounters.mTxBroadcast, aCounters.mTxAckRequested,
324                          aCounters.mTxAcked, aCounters.mTxNoAckRequested, aCounters.mTxData, aCounters.mTxDataPoll,
325                          aCounters.mTxBeacon, aCounters.mTxBeaconRequest, aCounters.mTxOther, aCounters.mTxRetry,
326                          aCounters.mTxErrCca, aCounters.mTxErrAbort, aCounters.mTxErrBusyChannel, aCounters.mRxTotal,
327                          aCounters.mRxUnicast, aCounters.mRxBroadcast, aCounters.mRxData, aCounters.mRxDataPoll,
328                          aCounters.mRxBeacon, aCounters.mRxBeaconRequest, aCounters.mRxOther,
329                          aCounters.mRxAddressFiltered, aCounters.mRxDestAddrFiltered, aCounters.mRxDuplicated,
330                          aCounters.mRxErrNoFrame, aCounters.mRxErrUnknownNeighbor, aCounters.mRxErrInvalidSrcAddr,
331                          aCounters.mRxErrSec, aCounters.mRxErrFcs, aCounters.mRxErrOther);
332     DBusMessageIter sub;
333     otbrError       error = OTBR_ERROR_NONE;
334 
335     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
336     SuccessOrExit(error = ConvertToTuple(&sub, args));
337     dbus_message_iter_next(aIter);
338 exit:
339     return error;
340 }
341 
DBusMessageEncode(DBusMessageIter * aIter,const IpCounters & aCounters)342 otbrError DBusMessageEncode(DBusMessageIter *aIter, const IpCounters &aCounters)
343 {
344     DBusMessageIter sub;
345     otbrError       error = OTBR_ERROR_NONE;
346     auto args = std::tie(aCounters.mTxSuccess, aCounters.mRxSuccess, aCounters.mTxFailure, aCounters.mRxFailure);
347 
348     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
349     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
350     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
351 exit:
352     return error;
353 }
354 
DBusMessageExtract(DBusMessageIter * aIter,IpCounters & aCounters)355 otbrError DBusMessageExtract(DBusMessageIter *aIter, IpCounters &aCounters)
356 {
357     DBusMessageIter sub;
358     otbrError       error = OTBR_ERROR_NONE;
359     auto args = std::tie(aCounters.mTxSuccess, aCounters.mRxSuccess, aCounters.mTxFailure, aCounters.mRxFailure);
360 
361     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
362     SuccessOrExit(error = ConvertToTuple(&sub, args));
363     dbus_message_iter_next(aIter);
364 exit:
365     return error;
366 }
367 
DBusMessageEncode(DBusMessageIter * aIter,const ChildInfo & aChildInfo)368 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ChildInfo &aChildInfo)
369 {
370     DBusMessageIter sub;
371     otbrError       error = OTBR_ERROR_NONE;
372     auto            args  = std::tie(aChildInfo.mExtAddress, aChildInfo.mTimeout, aChildInfo.mAge, aChildInfo.mRloc16,
373                                      aChildInfo.mChildId, aChildInfo.mNetworkDataVersion, aChildInfo.mLinkQualityIn,
374                                      aChildInfo.mAverageRssi, aChildInfo.mLastRssi, aChildInfo.mFrameErrorRate,
375                                      aChildInfo.mMessageErrorRate, aChildInfo.mRxOnWhenIdle, aChildInfo.mFullThreadDevice,
376                                      aChildInfo.mFullNetworkData, aChildInfo.mIsStateRestoring);
377 
378     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
379     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
380     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
381 exit:
382     return error;
383 }
384 
DBusMessageExtract(DBusMessageIter * aIter,ChildInfo & aChildInfo)385 otbrError DBusMessageExtract(DBusMessageIter *aIter, ChildInfo &aChildInfo)
386 {
387     DBusMessageIter sub;
388     otbrError       error = OTBR_ERROR_NONE;
389     auto            args  = std::tie(aChildInfo.mExtAddress, aChildInfo.mTimeout, aChildInfo.mAge, aChildInfo.mRloc16,
390                                      aChildInfo.mChildId, aChildInfo.mNetworkDataVersion, aChildInfo.mLinkQualityIn,
391                                      aChildInfo.mAverageRssi, aChildInfo.mLastRssi, aChildInfo.mFrameErrorRate,
392                                      aChildInfo.mMessageErrorRate, aChildInfo.mRxOnWhenIdle, aChildInfo.mFullThreadDevice,
393                                      aChildInfo.mFullNetworkData, aChildInfo.mIsStateRestoring);
394 
395     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
396     SuccessOrExit(error = ConvertToTuple(&sub, args));
397     dbus_message_iter_next(aIter);
398 exit:
399     return error;
400 }
401 
DBusMessageEncode(DBusMessageIter * aIter,const NeighborInfo & aNeighborInfo)402 otbrError DBusMessageEncode(DBusMessageIter *aIter, const NeighborInfo &aNeighborInfo)
403 {
404     DBusMessageIter sub;
405     otbrError       error = OTBR_ERROR_NONE;
406     auto            args  = std::tie(aNeighborInfo.mExtAddress, aNeighborInfo.mAge, aNeighborInfo.mRloc16,
407                                      aNeighborInfo.mLinkFrameCounter, aNeighborInfo.mMleFrameCounter, aNeighborInfo.mLinkQualityIn,
408                                      aNeighborInfo.mAverageRssi, aNeighborInfo.mLastRssi, aNeighborInfo.mFrameErrorRate,
409                                      aNeighborInfo.mMessageErrorRate, aNeighborInfo.mVersion, aNeighborInfo.mRxOnWhenIdle,
410                                      aNeighborInfo.mFullThreadDevice, aNeighborInfo.mFullNetworkData, aNeighborInfo.mIsChild);
411 
412     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
413     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
414     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
415 exit:
416     return error;
417 }
418 
DBusMessageExtract(DBusMessageIter * aIter,NeighborInfo & aNeighborInfo)419 otbrError DBusMessageExtract(DBusMessageIter *aIter, NeighborInfo &aNeighborInfo)
420 {
421     DBusMessageIter sub;
422     otbrError       error = OTBR_ERROR_NONE;
423     auto            args  = std::tie(aNeighborInfo.mExtAddress, aNeighborInfo.mAge, aNeighborInfo.mRloc16,
424                                      aNeighborInfo.mLinkFrameCounter, aNeighborInfo.mMleFrameCounter, aNeighborInfo.mLinkQualityIn,
425                                      aNeighborInfo.mAverageRssi, aNeighborInfo.mLastRssi, aNeighborInfo.mFrameErrorRate,
426                                      aNeighborInfo.mMessageErrorRate, aNeighborInfo.mVersion, aNeighborInfo.mRxOnWhenIdle,
427                                      aNeighborInfo.mFullThreadDevice, aNeighborInfo.mFullNetworkData, aNeighborInfo.mIsChild);
428 
429     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
430     SuccessOrExit(error = ConvertToTuple(&sub, args));
431     dbus_message_iter_next(aIter);
432 exit:
433     return error;
434 }
435 
DBusMessageEncode(DBusMessageIter * aIter,const LeaderData & aLeaderData)436 otbrError DBusMessageEncode(DBusMessageIter *aIter, const LeaderData &aLeaderData)
437 {
438     DBusMessageIter sub;
439     otbrError       error = OTBR_ERROR_NONE;
440     auto            args  = std::tie(aLeaderData.mPartitionId, aLeaderData.mWeighting, aLeaderData.mDataVersion,
441                                      aLeaderData.mStableDataVersion, aLeaderData.mLeaderRouterId);
442 
443     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
444     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
445     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
446 exit:
447     return error;
448 }
449 
DBusMessageExtract(DBusMessageIter * aIter,LeaderData & aLeaderData)450 otbrError DBusMessageExtract(DBusMessageIter *aIter, LeaderData &aLeaderData)
451 {
452     DBusMessageIter sub;
453     otbrError       error = OTBR_ERROR_NONE;
454     auto            args  = std::tie(aLeaderData.mPartitionId, aLeaderData.mWeighting, aLeaderData.mDataVersion,
455                                      aLeaderData.mStableDataVersion, aLeaderData.mLeaderRouterId);
456 
457     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
458     SuccessOrExit(error = ConvertToTuple(&sub, args));
459     dbus_message_iter_next(aIter);
460 exit:
461     return error;
462 }
463 
DBusMessageEncode(DBusMessageIter * aIter,const ChannelQuality & aQuality)464 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ChannelQuality &aQuality)
465 {
466     DBusMessageIter sub;
467     otbrError       error = OTBR_ERROR_NONE;
468     auto            args  = std::tie(aQuality.mChannel, aQuality.mOccupancy);
469 
470     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub));
471     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
472     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
473 exit:
474     return error;
475 }
476 
DBusMessageExtract(DBusMessageIter * aIter,ChannelQuality & aQuality)477 otbrError DBusMessageExtract(DBusMessageIter *aIter, ChannelQuality &aQuality)
478 {
479     DBusMessageIter sub;
480     otbrError       error = OTBR_ERROR_NONE;
481     auto            args  = std::tie(aQuality.mChannel, aQuality.mOccupancy);
482 
483     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
484     SuccessOrExit(error = ConvertToTuple(&sub, args));
485     dbus_message_iter_next(aIter);
486 exit:
487     return error;
488 }
489 
DBusMessageEncode(DBusMessageIter * aIter,const TxtEntry & aTxtEntry)490 otbrError DBusMessageEncode(DBusMessageIter *aIter, const TxtEntry &aTxtEntry)
491 {
492     DBusMessageIter sub;
493     otbrError       error = OTBR_ERROR_NONE;
494     auto            args  = std::tie(aTxtEntry.mKey, aTxtEntry.mValue);
495 
496     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub));
497     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
498     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
499 exit:
500     return error;
501 }
502 
DBusMessageExtract(DBusMessageIter * aIter,TxtEntry & aTxtEntry)503 otbrError DBusMessageExtract(DBusMessageIter *aIter, TxtEntry &aTxtEntry)
504 {
505     DBusMessageIter sub;
506     otbrError       error = OTBR_ERROR_NONE;
507     auto            args  = std::tie(aTxtEntry.mKey, aTxtEntry.mValue);
508 
509     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
510     SuccessOrExit(error = ConvertToTuple(&sub, args));
511     dbus_message_iter_next(aIter);
512 exit:
513     return error;
514 }
515 
DBusMessageEncode(DBusMessageIter * aIter,const SrpServerInfo::Registration & aRegistration)516 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo::Registration &aRegistration)
517 {
518     DBusMessageIter sub;
519     otbrError       error = OTBR_ERROR_NONE;
520     auto args = std::tie(aRegistration.mFreshCount, aRegistration.mDeletedCount, aRegistration.mLeaseTimeTotal,
521                          aRegistration.mKeyLeaseTimeTotal, aRegistration.mRemainingLeaseTimeTotal,
522                          aRegistration.mRemainingKeyLeaseTimeTotal);
523 
524     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
525     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
526     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
527 exit:
528     return error;
529 }
530 
DBusMessageExtract(DBusMessageIter * aIter,SrpServerInfo::Registration & aRegistration)531 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo::Registration &aRegistration)
532 {
533     DBusMessageIter sub;
534     otbrError       error = OTBR_ERROR_NONE;
535     auto args = std::tie(aRegistration.mFreshCount, aRegistration.mDeletedCount, aRegistration.mLeaseTimeTotal,
536                          aRegistration.mKeyLeaseTimeTotal, aRegistration.mRemainingLeaseTimeTotal,
537                          aRegistration.mRemainingKeyLeaseTimeTotal);
538 
539     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
540     SuccessOrExit(error = ConvertToTuple(&sub, args));
541     dbus_message_iter_next(aIter);
542 exit:
543     return error;
544 }
545 
DBusMessageEncode(DBusMessageIter * aIter,const SrpServerInfo::ResponseCounters & aResponseCounters)546 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo::ResponseCounters &aResponseCounters)
547 {
548     DBusMessageIter sub;
549     otbrError       error = OTBR_ERROR_NONE;
550     auto args = std::tie(aResponseCounters.mSuccess, aResponseCounters.mServerFailure, aResponseCounters.mFormatError,
551                          aResponseCounters.mNameExists, aResponseCounters.mRefused, aResponseCounters.mOther);
552 
553     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
554     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
555     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
556 exit:
557     return error;
558 }
559 
DBusMessageExtract(DBusMessageIter * aIter,SrpServerInfo::ResponseCounters & aResponseCounters)560 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo::ResponseCounters &aResponseCounters)
561 {
562     DBusMessageIter sub;
563     otbrError       error = OTBR_ERROR_NONE;
564     auto args = std::tie(aResponseCounters.mSuccess, aResponseCounters.mServerFailure, aResponseCounters.mFormatError,
565                          aResponseCounters.mNameExists, aResponseCounters.mRefused, aResponseCounters.mOther);
566 
567     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
568     SuccessOrExit(error = ConvertToTuple(&sub, args));
569     dbus_message_iter_next(aIter);
570 exit:
571     return error;
572 }
573 
DBusMessageEncode(DBusMessageIter * aIter,const SrpServerInfo & aSrpServerInfo)574 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo &aSrpServerInfo)
575 {
576     DBusMessageIter sub;
577     otbrError       error = OTBR_ERROR_NONE;
578 
579     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
580 
581     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mState));
582     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mPort));
583     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mAddressMode));
584     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mHosts));
585     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mServices));
586     SuccessOrExit(error = DBusMessageEncode(&sub, aSrpServerInfo.mResponseCounters));
587 
588     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
589 exit:
590     return error;
591 }
592 
DBusMessageExtract(DBusMessageIter * aIter,SrpServerInfo & aSrpServerInfo)593 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo &aSrpServerInfo)
594 {
595     DBusMessageIter sub;
596     otbrError       error = OTBR_ERROR_NONE;
597 
598     DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT);
599     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mState));
600     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mPort));
601     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mAddressMode));
602     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mHosts));
603     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mServices));
604     SuccessOrExit(error = DBusMessageExtract(&sub, aSrpServerInfo.mResponseCounters));
605 
606     dbus_message_iter_next(aIter);
607 exit:
608     return error;
609 }
610 
DBusMessageEncode(DBusMessageIter * aIter,const DnssdCounters & aDnssdCounters)611 otbrError DBusMessageEncode(DBusMessageIter *aIter, const DnssdCounters &aDnssdCounters)
612 {
613     DBusMessageIter sub;
614     otbrError       error = OTBR_ERROR_NONE;
615 
616     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
617 
618     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mSuccessResponse));
619     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mServerFailureResponse));
620     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mFormatErrorResponse));
621     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mNameErrorResponse));
622     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mNotImplementedResponse));
623     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mOtherResponse));
624 
625     SuccessOrExit(error = DBusMessageEncode(&sub, aDnssdCounters.mResolvedBySrp));
626 
627     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
628 exit:
629     return error;
630 }
631 
DBusMessageExtract(DBusMessageIter * aIter,DnssdCounters & aDnssdCounters)632 otbrError DBusMessageExtract(DBusMessageIter *aIter, DnssdCounters &aDnssdCounters)
633 {
634     DBusMessageIter sub;
635     otbrError       error = OTBR_ERROR_NONE;
636 
637     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
638 
639     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mSuccessResponse));
640     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mServerFailureResponse));
641     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mFormatErrorResponse));
642     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mNameErrorResponse));
643     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mNotImplementedResponse));
644     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mOtherResponse));
645 
646     SuccessOrExit(error = DBusMessageExtract(&sub, aDnssdCounters.mResolvedBySrp));
647 
648     dbus_message_iter_next(aIter);
649 exit:
650     return error;
651 }
652 
DBusMessageEncode(DBusMessageIter * aIter,const MdnsResponseCounters & aMdnsResponseCounters)653 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MdnsResponseCounters &aMdnsResponseCounters)
654 {
655     DBusMessageIter sub;
656     otbrError       error = OTBR_ERROR_NONE;
657 
658     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
659 
660     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mSuccess));
661     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mNotFound));
662     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mInvalidArgs));
663     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mDuplicated));
664     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mNotImplemented));
665     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mUnknownError));
666     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mAborted));
667     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsResponseCounters.mInvalidState));
668 
669     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
670 exit:
671     return error;
672 }
673 
DBusMessageExtract(DBusMessageIter * aIter,MdnsResponseCounters & aMdnsResponseCounters)674 otbrError DBusMessageExtract(DBusMessageIter *aIter, MdnsResponseCounters &aMdnsResponseCounters)
675 {
676     DBusMessageIter sub;
677     otbrError       error = OTBR_ERROR_NONE;
678 
679     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
680 
681     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mSuccess));
682     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mNotFound));
683     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mInvalidArgs));
684     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mDuplicated));
685     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mNotImplemented));
686     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mUnknownError));
687     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mAborted));
688     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsResponseCounters.mInvalidState));
689 
690     dbus_message_iter_next(aIter);
691 exit:
692     return error;
693 }
694 
DBusMessageEncode(DBusMessageIter * aIter,const MdnsTelemetryInfo & aMdnsTelemetryInfo)695 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MdnsTelemetryInfo &aMdnsTelemetryInfo)
696 {
697     DBusMessageIter sub;
698     otbrError       error = OTBR_ERROR_NONE;
699 
700     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
701 
702     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mHostRegistrations));
703     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mServiceRegistrations));
704     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mHostResolutions));
705     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mServiceResolutions));
706 
707     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mHostRegistrationEmaLatency));
708     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mServiceRegistrationEmaLatency));
709     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mHostResolutionEmaLatency));
710     SuccessOrExit(error = DBusMessageEncode(&sub, aMdnsTelemetryInfo.mServiceResolutionEmaLatency));
711 
712     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
713 exit:
714     return error;
715 }
716 
DBusMessageExtract(DBusMessageIter * aIter,MdnsTelemetryInfo & aMdnsTelemetryInfo)717 otbrError DBusMessageExtract(DBusMessageIter *aIter, MdnsTelemetryInfo &aMdnsTelemetryInfo)
718 {
719     DBusMessageIter sub;
720     otbrError       error = OTBR_ERROR_NONE;
721 
722     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
723 
724     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mHostRegistrations));
725     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mServiceRegistrations));
726     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mHostResolutions));
727     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mServiceResolutions));
728 
729     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mHostRegistrationEmaLatency));
730     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mServiceRegistrationEmaLatency));
731     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mHostResolutionEmaLatency));
732     SuccessOrExit(error = DBusMessageExtract(&sub, aMdnsTelemetryInfo.mServiceResolutionEmaLatency));
733 
734     dbus_message_iter_next(aIter);
735 exit:
736     return error;
737 }
738 
DBusMessageEncode(DBusMessageIter * aIter,const RadioSpinelMetrics & aRadioSpinelMetrics)739 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RadioSpinelMetrics &aRadioSpinelMetrics)
740 {
741     DBusMessageIter sub;
742     otbrError       error = OTBR_ERROR_NONE;
743 
744     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
745 
746     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioSpinelMetrics.mRcpTimeoutCount));
747     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioSpinelMetrics.mRcpUnexpectedResetCount));
748     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioSpinelMetrics.mRcpRestorationCount));
749     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioSpinelMetrics.mSpinelParseErrorCount));
750 
751     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
752 exit:
753     return error;
754 }
755 
DBusMessageExtract(DBusMessageIter * aIter,RadioSpinelMetrics & aRadioSpinelMetrics)756 otbrError DBusMessageExtract(DBusMessageIter *aIter, RadioSpinelMetrics &aRadioSpinelMetrics)
757 {
758     DBusMessageIter sub;
759     otbrError       error = OTBR_ERROR_NONE;
760 
761     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
762 
763     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioSpinelMetrics.mRcpTimeoutCount));
764     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioSpinelMetrics.mRcpUnexpectedResetCount));
765     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioSpinelMetrics.mRcpRestorationCount));
766     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioSpinelMetrics.mSpinelParseErrorCount));
767 
768     dbus_message_iter_next(aIter);
769 exit:
770     return error;
771 }
772 
DBusMessageEncode(DBusMessageIter * aIter,const RcpInterfaceMetrics & aRcpInterfaceMetrics)773 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RcpInterfaceMetrics &aRcpInterfaceMetrics)
774 {
775     DBusMessageIter sub;
776     otbrError       error = OTBR_ERROR_NONE;
777 
778     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
779 
780     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mRcpInterfaceType));
781     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mTransferredFrameCount));
782     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mTransferredValidFrameCount));
783     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mTransferredGarbageFrameCount));
784     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mRxFrameCount));
785     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mRxFrameByteCount));
786     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mTxFrameCount));
787     SuccessOrExit(error = DBusMessageEncode(&sub, aRcpInterfaceMetrics.mTxFrameByteCount));
788 
789     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
790 exit:
791     return error;
792 }
793 
DBusMessageExtract(DBusMessageIter * aIter,RcpInterfaceMetrics & aRcpInterfaceMetrics)794 otbrError DBusMessageExtract(DBusMessageIter *aIter, RcpInterfaceMetrics &aRcpInterfaceMetrics)
795 {
796     DBusMessageIter sub;
797     otbrError       error = OTBR_ERROR_NONE;
798 
799     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
800 
801     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mRcpInterfaceType));
802     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mTransferredFrameCount));
803     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mTransferredValidFrameCount));
804     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mTransferredGarbageFrameCount));
805     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mRxFrameCount));
806     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mRxFrameByteCount));
807     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mTxFrameCount));
808     SuccessOrExit(error = DBusMessageExtract(&sub, aRcpInterfaceMetrics.mTxFrameByteCount));
809 
810     dbus_message_iter_next(aIter);
811 exit:
812     return error;
813 }
814 
DBusMessageEncode(DBusMessageIter * aIter,const RadioCoexMetrics & aRadioCoexMetrics)815 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RadioCoexMetrics &aRadioCoexMetrics)
816 {
817     DBusMessageIter sub;
818     otbrError       error = OTBR_ERROR_NONE;
819 
820     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
821 
822     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumGrantGlitch));
823     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxRequest));
824     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxGrantImmediate));
825     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxGrantWait));
826     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxGrantWaitActivated));
827     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxGrantWaitTimeout));
828     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxGrantDeactivatedDuringRequest));
829     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumTxDelayedGrant));
830     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mAvgTxRequestToGrantTime));
831     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxRequest));
832     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantImmediate));
833     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantWait));
834     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantWaitActivated));
835     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantWaitTimeout));
836     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantDeactivatedDuringRequest));
837     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxDelayedGrant));
838     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mAvgRxRequestToGrantTime));
839     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mNumRxGrantNone));
840     SuccessOrExit(error = DBusMessageEncode(&sub, aRadioCoexMetrics.mStopped));
841 
842     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
843 exit:
844     return error;
845 }
846 
DBusMessageExtract(DBusMessageIter * aIter,RadioCoexMetrics & aRadioCoexMetrics)847 otbrError DBusMessageExtract(DBusMessageIter *aIter, RadioCoexMetrics &aRadioCoexMetrics)
848 {
849     DBusMessageIter sub;
850     otbrError       error = OTBR_ERROR_NONE;
851 
852     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
853 
854     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumGrantGlitch));
855     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxRequest));
856     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxGrantImmediate));
857     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxGrantWait));
858     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxGrantWaitActivated));
859     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxGrantWaitTimeout));
860     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxGrantDeactivatedDuringRequest));
861     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumTxDelayedGrant));
862     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mAvgTxRequestToGrantTime));
863     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxRequest));
864     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantImmediate));
865     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantWait));
866     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantWaitActivated));
867     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantWaitTimeout));
868     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantDeactivatedDuringRequest));
869     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxDelayedGrant));
870     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mAvgRxRequestToGrantTime));
871     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mNumRxGrantNone));
872     SuccessOrExit(error = DBusMessageExtract(&sub, aRadioCoexMetrics.mStopped));
873 
874     dbus_message_iter_next(aIter);
875 exit:
876     return error;
877 }
878 
DBusMessageEncode(DBusMessageIter * aIter,const BorderRoutingCounters::PacketsAndBytes & aPacketsAndBytes)879 otbrError DBusMessageEncode(DBusMessageIter *aIter, const BorderRoutingCounters::PacketsAndBytes &aPacketsAndBytes)
880 {
881     DBusMessageIter sub;
882     otbrError       error = OTBR_ERROR_NONE;
883 
884     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
885 
886     SuccessOrExit(error = DBusMessageEncode(&sub, aPacketsAndBytes.mPackets));
887     SuccessOrExit(error = DBusMessageEncode(&sub, aPacketsAndBytes.mBytes));
888 
889     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
890 
891 exit:
892     return error;
893 }
894 
DBusMessageExtract(DBusMessageIter * aIter,BorderRoutingCounters::PacketsAndBytes & aPacketsAndBytes)895 otbrError DBusMessageExtract(DBusMessageIter *aIter, BorderRoutingCounters::PacketsAndBytes &aPacketsAndBytes)
896 {
897     DBusMessageIter sub;
898     otbrError       error = OTBR_ERROR_NONE;
899 
900     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
901 
902     SuccessOrExit(error = DBusMessageExtract(&sub, aPacketsAndBytes.mPackets));
903     SuccessOrExit(error = DBusMessageExtract(&sub, aPacketsAndBytes.mBytes));
904 
905     dbus_message_iter_next(aIter);
906 
907 exit:
908     return error;
909 }
910 
DBusMessageEncode(DBusMessageIter * aIter,const BorderRoutingCounters & aBorderRoutingCounters)911 otbrError DBusMessageEncode(DBusMessageIter *aIter, const BorderRoutingCounters &aBorderRoutingCounters)
912 {
913     DBusMessageIter sub;
914     otbrError       error = OTBR_ERROR_NONE;
915 
916     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
917 
918     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mInboundUnicast));
919     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mInboundMulticast));
920     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mOutboundUnicast));
921     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mOutboundMulticast));
922     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRaRx));
923     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRaTxSuccess));
924     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRaTxFailure));
925     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRsRx));
926     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRsTxSuccess));
927     SuccessOrExit(error = DBusMessageEncode(&sub, aBorderRoutingCounters.mRsTxFailure));
928 
929     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
930 
931 exit:
932     return error;
933 }
934 
DBusMessageExtract(DBusMessageIter * aIter,BorderRoutingCounters & aBorderRoutingCounters)935 otbrError DBusMessageExtract(DBusMessageIter *aIter, BorderRoutingCounters &aBorderRoutingCounters)
936 {
937     DBusMessageIter sub;
938     otbrError       error = OTBR_ERROR_NONE;
939 
940     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
941 
942     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mInboundUnicast));
943     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mInboundMulticast));
944     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mOutboundUnicast));
945     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mOutboundMulticast));
946     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRaRx));
947     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRaTxSuccess));
948     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRaTxFailure));
949     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRsRx));
950     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRsTxSuccess));
951     SuccessOrExit(error = DBusMessageExtract(&sub, aBorderRoutingCounters.mRsTxFailure));
952 
953     dbus_message_iter_next(aIter);
954 
955 exit:
956     return error;
957 }
958 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64ComponentState & aNat64State)959 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ComponentState &aNat64State)
960 {
961     DBusMessageIter sub;
962     otbrError       error = OTBR_ERROR_NONE;
963 
964     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
965 
966     SuccessOrExit(error = DBusMessageEncode(&sub, aNat64State.mPrefixManagerState));
967     SuccessOrExit(error = DBusMessageEncode(&sub, aNat64State.mTranslatorState));
968 
969     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
970 exit:
971     return error;
972 }
973 
DBusMessageExtract(DBusMessageIter * aIter,Nat64ComponentState & aNat64State)974 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ComponentState &aNat64State)
975 {
976     DBusMessageIter sub;
977     otbrError       error = OTBR_ERROR_NONE;
978 
979     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
980 
981     SuccessOrExit(error = DBusMessageExtract(&sub, aNat64State.mPrefixManagerState));
982     SuccessOrExit(error = DBusMessageExtract(&sub, aNat64State.mTranslatorState));
983 
984     dbus_message_iter_next(aIter);
985 exit:
986     return error;
987 }
988 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64TrafficCounters & aCounters)989 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64TrafficCounters &aCounters)
990 {
991     DBusMessageIter sub;
992     otbrError       error = OTBR_ERROR_NONE;
993 
994     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
995 
996     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m4To6Packets));
997     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m4To6Bytes));
998     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m6To4Packets));
999     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m6To4Bytes));
1000 
1001     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1002 exit:
1003     return error;
1004 }
1005 
DBusMessageExtract(DBusMessageIter * aIter,Nat64TrafficCounters & aCounters)1006 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64TrafficCounters &aCounters)
1007 {
1008     DBusMessageIter sub;
1009     otbrError       error = OTBR_ERROR_NONE;
1010 
1011     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1012 
1013     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m4To6Packets));
1014     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m4To6Bytes));
1015     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m6To4Packets));
1016     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m6To4Bytes));
1017 
1018     dbus_message_iter_next(aIter);
1019 exit:
1020     return error;
1021 }
1022 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64PacketCounters & aCounters)1023 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64PacketCounters &aCounters)
1024 {
1025     DBusMessageIter sub;
1026     otbrError       error = OTBR_ERROR_NONE;
1027 
1028     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1029 
1030     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m4To6Packets));
1031     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.m6To4Packets));
1032 
1033     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1034 exit:
1035     return error;
1036 }
1037 
DBusMessageExtract(DBusMessageIter * aIter,Nat64PacketCounters & aCounters)1038 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64PacketCounters &aCounters)
1039 {
1040     DBusMessageIter sub;
1041     otbrError       error = OTBR_ERROR_NONE;
1042 
1043     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1044 
1045     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m4To6Packets));
1046     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.m6To4Packets));
1047 
1048     dbus_message_iter_next(aIter);
1049 exit:
1050     return error;
1051 }
1052 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64ProtocolCounters & aCounters)1053 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ProtocolCounters &aCounters)
1054 {
1055     DBusMessageIter sub;
1056     otbrError       error = OTBR_ERROR_NONE;
1057 
1058     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1059 
1060     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mTotal));
1061     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mIcmp));
1062     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mUdp));
1063     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mTcp));
1064 
1065     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1066 exit:
1067     return error;
1068 }
1069 
DBusMessageExtract(DBusMessageIter * aIter,Nat64ProtocolCounters & aCounters)1070 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ProtocolCounters &aCounters)
1071 {
1072     DBusMessageIter sub;
1073     otbrError       error = OTBR_ERROR_NONE;
1074 
1075     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1076 
1077     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mTotal));
1078     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mIcmp));
1079     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mUdp));
1080     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mTcp));
1081 
1082     dbus_message_iter_next(aIter);
1083 exit:
1084     return error;
1085 }
1086 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64AddressMapping & aMapping)1087 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64AddressMapping &aMapping)
1088 {
1089     DBusMessageIter sub;
1090     otbrError       error = OTBR_ERROR_NONE;
1091 
1092     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1093 
1094     SuccessOrExit(error = DBusMessageEncode(&sub, aMapping.mId));
1095     SuccessOrExit(error = DBusMessageEncode(&sub, aMapping.mIp4));
1096     SuccessOrExit(error = DBusMessageEncode(&sub, aMapping.mIp6));
1097     SuccessOrExit(error = DBusMessageEncode(&sub, aMapping.mRemainingTimeMs));
1098     SuccessOrExit(error = DBusMessageEncode(&sub, aMapping.mCounters));
1099 
1100     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1101 exit:
1102     return error;
1103 }
1104 
DBusMessageExtract(DBusMessageIter * aIter,Nat64AddressMapping & aMapping)1105 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64AddressMapping &aMapping)
1106 {
1107     DBusMessageIter sub;
1108     otbrError       error = OTBR_ERROR_NONE;
1109 
1110     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1111 
1112     SuccessOrExit(error = DBusMessageExtract(&sub, aMapping.mId));
1113     SuccessOrExit(error = DBusMessageExtract(&sub, aMapping.mIp4));
1114     SuccessOrExit(error = DBusMessageExtract(&sub, aMapping.mIp6));
1115     SuccessOrExit(error = DBusMessageExtract(&sub, aMapping.mRemainingTimeMs));
1116     SuccessOrExit(error = DBusMessageExtract(&sub, aMapping.mCounters));
1117 
1118     dbus_message_iter_next(aIter);
1119 exit:
1120     return error;
1121 }
1122 
DBusMessageEncode(DBusMessageIter * aIter,const Nat64ErrorCounters & aCounters)1123 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ErrorCounters &aCounters)
1124 {
1125     DBusMessageIter sub;
1126     otbrError       error = OTBR_ERROR_NONE;
1127 
1128     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1129 
1130     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mUnknown));
1131     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mIllegalPacket));
1132     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mUnsupportedProto));
1133     SuccessOrExit(error = DBusMessageEncode(&sub, aCounters.mNoMapping));
1134 
1135     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1136 exit:
1137     return error;
1138 }
1139 
DBusMessageExtract(DBusMessageIter * aIter,Nat64ErrorCounters & aCounters)1140 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ErrorCounters &aCounters)
1141 {
1142     DBusMessageIter sub;
1143     otbrError       error = OTBR_ERROR_NONE;
1144 
1145     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1146 
1147     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mUnknown));
1148     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mIllegalPacket));
1149     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mUnsupportedProto));
1150     SuccessOrExit(error = DBusMessageExtract(&sub, aCounters.mNoMapping));
1151 
1152     dbus_message_iter_next(aIter);
1153 exit:
1154     return error;
1155 }
1156 
DBusMessageEncode(DBusMessageIter * aIter,const InfraLinkInfo & aInfraLinkInfo)1157 otbrError DBusMessageEncode(DBusMessageIter *aIter, const InfraLinkInfo &aInfraLinkInfo)
1158 {
1159     DBusMessageIter sub;
1160     otbrError       error = OTBR_ERROR_NONE;
1161 
1162     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1163 
1164     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mName));
1165     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mIsUp));
1166     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mIsRunning));
1167     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mIsMulticast));
1168     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mLinkLocalAddressCount));
1169     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mUniqueLocalAddressCount));
1170     SuccessOrExit(error = DBusMessageEncode(&sub, aInfraLinkInfo.mGlobalUnicastAddressCount));
1171 
1172     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1173 exit:
1174     return error;
1175 }
1176 
DBusMessageExtract(DBusMessageIter * aIter,InfraLinkInfo & aInfraLinkInfo)1177 otbrError DBusMessageExtract(DBusMessageIter *aIter, InfraLinkInfo &aInfraLinkInfo)
1178 {
1179     DBusMessageIter sub;
1180     otbrError       error = OTBR_ERROR_NONE;
1181 
1182     SuccessOrExit(error = DbusMessageIterRecurse(aIter, &sub, DBUS_TYPE_STRUCT));
1183 
1184     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mName));
1185     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mIsUp));
1186     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mIsRunning));
1187     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mIsMulticast));
1188     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mLinkLocalAddressCount));
1189     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mUniqueLocalAddressCount));
1190     SuccessOrExit(error = DBusMessageExtract(&sub, aInfraLinkInfo.mGlobalUnicastAddressCount));
1191 
1192     dbus_message_iter_next(aIter);
1193 exit:
1194     return error;
1195 }
1196 
DBusMessageEncode(DBusMessageIter * aIter,const TrelInfo & aTrelInfo)1197 otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo &aTrelInfo)
1198 {
1199     DBusMessageIter sub;
1200     otbrError       error = OTBR_ERROR_NONE;
1201 
1202     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1203 
1204     SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mEnabled));
1205     SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mNumTrelPeers));
1206     SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mTrelCounters));
1207 
1208     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
1209 exit:
1210     return error;
1211 }
1212 
DBusMessageExtract(DBusMessageIter * aIter,TrelInfo & aTrelInfo)1213 otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo &aTrelInfo)
1214 {
1215     DBusMessageIter sub;
1216     otbrError       error = OTBR_ERROR_NONE;
1217 
1218     dbus_message_iter_recurse(aIter, &sub);
1219 
1220     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mEnabled));
1221     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mNumTrelPeers));
1222     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mTrelCounters));
1223 
1224     dbus_message_iter_next(aIter);
1225 exit:
1226     return error;
1227 }
1228 
DBusMessageEncode(DBusMessageIter * aIter,const TrelInfo::TrelPacketCounters & aTrelCounters)1229 otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo::TrelPacketCounters &aTrelCounters)
1230 {
1231     DBusMessageIter sub;
1232     otbrError       error = OTBR_ERROR_NONE;
1233     auto            args  = std::tie(aTrelCounters.mTxPackets, aTrelCounters.mTxBytes, aTrelCounters.mTxFailure,
1234                                      aTrelCounters.mRxPackets, aTrelCounters.mRxBytes);
1235 
1236     VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
1237     SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
1238     VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
1239 exit:
1240     return error;
1241 }
1242 
DBusMessageExtract(DBusMessageIter * aIter,TrelInfo::TrelPacketCounters & aTrelCounters)1243 otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo::TrelPacketCounters &aTrelCounters)
1244 {
1245     DBusMessageIter sub;
1246     otbrError       error = OTBR_ERROR_NONE;
1247 
1248     dbus_message_iter_recurse(aIter, &sub);
1249 
1250     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxPackets));
1251     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxBytes));
1252     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxFailure));
1253     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mRxPackets));
1254     SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mRxBytes));
1255 
1256     dbus_message_iter_next(aIter);
1257 exit:
1258     return error;
1259 }
1260 
1261 } // namespace DBus
1262 } // namespace otbr
1263