openthread-br  0.3.0-72c0388
dbus_message_helper.hpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019, 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 
34 #ifndef DBUS_MESSAGE_HELPER_HPP_
35 #define DBUS_MESSAGE_HELPER_HPP_
36 
37 #include <array>
38 #include <string>
39 #include <tuple>
40 #include <vector>
41 
42 #include <dbus/dbus.h>
43 
44 #include "common/code_utils.hpp"
45 #include "common/types.hpp"
46 #include "dbus/common/dbus_resources.hpp"
47 #include "dbus/common/types.hpp"
48 
49 namespace otbr {
50 namespace DBus {
51 
52 otbrError DBusMessageEncode(DBusMessageIter *aIter, const otbrError &aError);
53 otbrError DBusMessageExtract(DBusMessageIter *aIter, otbrError &aError);
54 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ActiveScanResult &aScanResult);
55 otbrError DBusMessageExtract(DBusMessageIter *aIter, ActiveScanResult &aScanResult);
56 otbrError DBusMessageEncode(DBusMessageIter *aIter, const EnergyScanResult &aResult);
57 otbrError DBusMessageExtract(DBusMessageIter *aIter, EnergyScanResult &aResult);
58 otbrError DBusMessageEncode(DBusMessageIter *aIter, const LinkModeConfig &aConfig);
59 otbrError DBusMessageExtract(DBusMessageIter *aIter, LinkModeConfig &aConfig);
60 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Ip6Prefix &aPrefix);
61 otbrError DBusMessageExtract(DBusMessageIter *aIter, Ip6Prefix &aPrefix);
62 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ExternalRoute &aRoute);
63 otbrError DBusMessageExtract(DBusMessageIter *aIter, ExternalRoute &aRoute);
64 otbrError DBusMessageEncode(DBusMessageIter *aIter, const OnMeshPrefix &aPrefix);
65 otbrError DBusMessageExtract(DBusMessageIter *aIter, OnMeshPrefix &aPrefix);
66 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MacCounters &aCounters);
67 otbrError DBusMessageExtract(DBusMessageIter *aIter, MacCounters &aCounters);
68 otbrError DBusMessageEncode(DBusMessageIter *aIter, const IpCounters &aCounters);
69 otbrError DBusMessageExtract(DBusMessageIter *aIter, IpCounters &aCounters);
70 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ChildInfo &aChildInfo);
71 otbrError DBusMessageExtract(DBusMessageIter *aIter, ChildInfo &aChildInfo);
72 otbrError DBusMessageEncode(DBusMessageIter *aIter, const NeighborInfo &aNeighborInfo);
73 otbrError DBusMessageExtract(DBusMessageIter *aIter, NeighborInfo &aNeighborInfo);
74 otbrError DBusMessageEncode(DBusMessageIter *aIter, const LeaderData &aLeaderData);
75 otbrError DBusMessageExtract(DBusMessageIter *aIter, LeaderData &aLeaderData);
76 otbrError DBusMessageEncode(DBusMessageIter *aIter, const ChannelQuality &aQuality);
77 otbrError DBusMessageExtract(DBusMessageIter *aIter, ChannelQuality &aQuality);
78 otbrError DBusMessageEncode(DBusMessageIter *aIter, const TxtEntry &aTxtEntry);
79 otbrError DBusMessageExtract(DBusMessageIter *aIter, TxtEntry &aTxtEntry);
80 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo::Registration &aRegistration);
81 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo::Registration &aRegistration);
82 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo::ResponseCounters &aResponseCounters);
83 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo::ResponseCounters &aResponseCounters);
84 otbrError DBusMessageEncode(DBusMessageIter *aIter, const SrpServerInfo &aSrpServerInfo);
85 otbrError DBusMessageExtract(DBusMessageIter *aIter, SrpServerInfo &aSrpServerInfo);
86 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MdnsResponseCounters &aMdnsResponseCounters);
87 otbrError DBusMessageExtract(DBusMessageIter *aIter, MdnsResponseCounters &aMdnsResponseCounters);
88 otbrError DBusMessageEncode(DBusMessageIter *aIter, const MdnsTelemetryInfo &aMdnsTelemetryInfo);
89 otbrError DBusMessageExtract(DBusMessageIter *aIter, MdnsTelemetryInfo &aMdnsTelemetryInfo);
90 otbrError DBusMessageEncode(DBusMessageIter *aIter, const DnssdCounters &aDnssdCounters);
91 otbrError DBusMessageExtract(DBusMessageIter *aIter, DnssdCounters &aDnssdCounters);
92 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RadioSpinelMetrics &aRadioSpinelMetrics);
93 otbrError DBusMessageExtract(DBusMessageIter *aIter, RadioSpinelMetrics &RadioSpinelMetrics);
94 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RcpInterfaceMetrics &aRcpInterfaceMetrics);
95 otbrError DBusMessageExtract(DBusMessageIter *aIter, RcpInterfaceMetrics &aRcpInterfaceMetrics);
96 otbrError DBusMessageEncode(DBusMessageIter *aIter, const RadioCoexMetrics &aRadioCoexMetrics);
97 otbrError DBusMessageExtract(DBusMessageIter *aIter, RadioCoexMetrics &aRadioCoexMetrics);
98 otbrError DBusMessageEncode(DBusMessageIter *aIter, const BorderRoutingCounters::PacketsAndBytes &aPacketAndBytes);
99 otbrError DBusMessageExtract(DBusMessageIter *aIter, BorderRoutingCounters::PacketsAndBytes &aPacketAndBytes);
100 otbrError DBusMessageEncode(DBusMessageIter *aIter, const BorderRoutingCounters &aBorderRoutingCounters);
101 otbrError DBusMessageExtract(DBusMessageIter *aIter, BorderRoutingCounters &aBorderRoutingCounters);
102 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ComponentState &aNat64State);
103 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ComponentState &aNat64State);
104 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64TrafficCounters &aCounters);
105 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64TrafficCounters &aCounters);
106 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64PacketCounters &aCounters);
107 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64PacketCounters &aCounters);
108 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ProtocolCounters &aCounters);
109 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ProtocolCounters &aCounters);
110 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64AddressMapping &aMapping);
111 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64AddressMapping &aMapping);
112 otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ErrorCounters &aCounters);
113 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ErrorCounters &aCounters);
114 
115 template <typename T> struct DBusTypeTrait;
116 
117 template <> struct DBusTypeTrait<IpCounters>
118 {
119  // struct of 32 bytes
120  static constexpr const char *TYPE_AS_STRING = "(uuuu)";
121 };
122 
123 template <> struct DBusTypeTrait<MacCounters>
124 {
125  // struct of 32 bytes
126  static constexpr const char *TYPE_AS_STRING = "(uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu)";
127 };
128 
129 template <> struct DBusTypeTrait<LinkModeConfig>
130 {
131  // struct of four booleans
132  static constexpr const char *TYPE_AS_STRING = "(bbb)";
133 };
134 
135 template <> struct DBusTypeTrait<std::vector<uint8_t>>
136 {
137  // array of bytes
138  static constexpr const char *TYPE_AS_STRING = "ay";
139 };
140 
141 template <size_t SIZE> struct DBusTypeTrait<std::array<uint8_t, SIZE>>
142 {
143  // array of bytes
144  static constexpr const char *TYPE_AS_STRING = "ay";
145 };
146 
147 template <> struct DBusTypeTrait<Ip6Prefix>
148 {
149  // struct of {array of bytes, byte}
150  static constexpr const char *TYPE_AS_STRING = "(ayy)";
151 };
152 
153 template <> struct DBusTypeTrait<ExternalRoute>
154 {
155  // struct of {{array of bytes, byte}, uint16, byte, bool, bool}
156  static constexpr const char *TYPE_AS_STRING = "((ayy)qybb)";
157 };
158 
159 template <> struct DBusTypeTrait<std::vector<ExternalRoute>>
160 {
161  // array of {{array of bytes, byte}, uint16, byte, bool, bool}
162  static constexpr const char *TYPE_AS_STRING = "a((ayy)qybb)";
163 };
164 
165 template <> struct DBusTypeTrait<OnMeshPrefix>
166 {
167  // struct of {{array of bytes, byte}, uint16, byte, bool, bool, bool, bool, bool, bool, bool, bool, bool}
168  static constexpr const char *TYPE_AS_STRING = "((ayy)qybbbbbbbbb)";
169 };
170 
171 template <> struct DBusTypeTrait<std::vector<OnMeshPrefix>>
172 {
173  // array of {{array of bytes, byte}, uint16, byte, bool, bool, bool, bool, bool, bool, bool, bool, bool}
174  static constexpr const char *TYPE_AS_STRING = "a((ayy)qybbbbbbbbb)";
175 };
176 
177 template <> struct DBusTypeTrait<LeaderData>
178 {
179  // struct of { uint32, byte, byte, byte, byte }
180  static constexpr const char *TYPE_AS_STRING = "(uyyyy)";
181 };
182 
183 template <> struct DBusTypeTrait<std::vector<ChannelQuality>>
184 {
185  // array of struct of { uint8, uint16 }
186  static constexpr const char *TYPE_AS_STRING = "a(yq)";
187 };
188 
189 template <> struct DBusTypeTrait<NeighborInfo>
190 {
191  // struct of { uint64, uint32, uint16, uint32, uint32, uint8,
192  // uint8, uint8, uint16, uint16, bool, bool, bool, bool }
193  static constexpr const char *TYPE_AS_STRING = "(tuquuyyyqqbbbb)";
194 };
195 
196 template <> struct DBusTypeTrait<std::vector<NeighborInfo>>
197 {
198  // array of struct of { uint64, uint32, uint16, uint32, uint32, uint8,
199  // uint8, uint8, uint16, uint16, bool, bool, bool }
200  static constexpr const char *TYPE_AS_STRING = "a(tuquuyyyqqbbbb)";
201 };
202 
203 template <> struct DBusTypeTrait<ChildInfo>
204 {
205  // struct of { uint64, uint32, uint32, uint16, uint16, uint8, uint8,
206  // uint8, uint8, uint16, uint16, bool, bool, bool, bool }
207  static constexpr const char *TYPE_AS_STRING = "(tuuqqyyyyqqbbbb)";
208 };
209 
210 template <> struct DBusTypeTrait<ActiveScanResult>
211 {
212  // struct of { uint64, string, uint64, array<uint8>, uint16, uint16, uint8,
213  // uint8, uint8, uint8, bool, bool }
214  static constexpr const char *TYPE_AS_STRING = "(tstayqqyyyybb)";
215 };
216 
217 template <> struct DBusTypeTrait<EnergyScanResult>
218 {
219  // struct of { uint8, int8_t }
220  static constexpr const char *TYPE_AS_STRING = "(yy)";
221 };
222 
223 template <> struct DBusTypeTrait<ChannelQuality>
224 {
225  // struct of { uint8, uint16}
226  static constexpr const char *TYPE_AS_STRING = "(yq)";
227 };
228 
229 template <> struct DBusTypeTrait<std::vector<ChildInfo>>
230 {
231  // array of struct of { uint64, uint32, uint32, uint16, uint16, uint8, uint8,
232  // uint8, uint8, uint16, uint16, bool, bool, bool, bool }
233  static constexpr const char *TYPE_AS_STRING = "a(tuuqqyyyyqqbbbb)";
234 };
235 
236 template <> struct DBusTypeTrait<TxtEntry>
237 {
238  // struct of { string, array<uint8> }
239  static constexpr const char *TYPE_AS_STRING = "(say)";
240 };
241 
242 template <> struct DBusTypeTrait<std::vector<TxtEntry>>
243 {
244  // array of struct of { string, array<uint8> }
245  static constexpr const char *TYPE_AS_STRING = "a(say)";
246 };
247 
248 template <> struct DBusTypeTrait<SrpServerState>
249 {
250  static constexpr int TYPE = DBUS_TYPE_BYTE;
251  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_BYTE_AS_STRING;
252 };
253 
254 template <> struct DBusTypeTrait<SrpServerAddressMode>
255 {
256  static constexpr int TYPE = DBUS_TYPE_BYTE;
257  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_BYTE_AS_STRING;
258 };
259 
260 template <> struct DBusTypeTrait<SrpServerInfo>
261 {
262  // struct of { uint8, uint16, uint8,
263  // struct of { uint32, uint32, uint64, uint64, uint64, uint64 },
264  // struct of { uint32, uint32, uint64, uint64, uint64, uint64 },
265  // struct of { uint32, uint32, uint32, uint32, uint32, uint32} }
266  static constexpr const char *TYPE_AS_STRING = "(yqy(uutttt)(uutttt)(uuuuuu))";
267 };
268 
269 template <> struct DBusTypeTrait<MdnsTelemetryInfo>
270 {
271  // struct of { struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32 },
272  // struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32 },
273  // struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32 },
274  // struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32 },
275  // uint32, uint32, uint32, uint32 }
276  static constexpr const char *TYPE_AS_STRING = "((uuuuuuuu)(uuuuuuuu)(uuuuuuuu)(uuuuuuuu)uuuu)";
277 };
278 
279 template <> struct DBusTypeTrait<DnssdCounters>
280 {
281  // struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32 }
282  static constexpr const char *TYPE_AS_STRING = "(uuuuuuu)";
283 };
284 
285 template <> struct DBusTypeTrait<RadioSpinelMetrics>
286 {
287  // struct of { uint32, uint32, uint32, uint32 }
288  static constexpr const char *TYPE_AS_STRING = "(uuuu)";
289 };
290 
291 template <> struct DBusTypeTrait<RcpInterfaceMetrics>
292 {
293  // struct of { uint8, uint64, uint64, uint64, uint64, uint64, uint64, uint64 }
294  static constexpr const char *TYPE_AS_STRING = "(yttttttt)";
295 };
296 
297 template <> struct DBusTypeTrait<RadioCoexMetrics>
298 {
299  // struct of { uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32,
300  // uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32,
301  // uint32, uint32, bool }
302  static constexpr const char *TYPE_AS_STRING = "(uuuuuuuuuuuuuuuuuub)";
303 };
304 
305 template <> struct DBusTypeTrait<BorderRoutingCounters>
306 {
307  // struct of { struct of { uint64, uint64 },
308  // struct of { uint64, uint64 },
309  // struct of { uint64, uint64 },
310  // struct of { uint64, uint64 } }
311  static constexpr const char *TYPE_AS_STRING = "((tt)(tt)(tt)(tt))";
312 };
313 
314 template <> struct DBusTypeTrait<Nat64ComponentState>
315 {
316  // struct of { uint8, uint8 }
317  static constexpr const char *TYPE_AS_STRING = "(ss)";
318 };
319 
320 template <> struct DBusTypeTrait<Nat64TrafficCounters>
321 {
322  // struct of { uint64, uint64, uint64, uint64 }
323  static constexpr const char *TYPE_AS_STRING = "(tttt)";
324 };
325 
326 template <> struct DBusTypeTrait<Nat64PacketCounters>
327 {
328  // struct of { uint64, uint64 }
329  static constexpr const char *TYPE_AS_STRING = "(tt)";
330 };
331 
332 template <> struct DBusTypeTrait<Nat64ProtocolCounters>
333 {
334  // struct of { struct of { uint64, uint64, uint64, uint64 }
335  // struct of { uint64, uint64, uint64, uint64 }
336  // struct of { uint64, uint64, uint64, uint64 }
337  // struct of { uint64, uint64, uint64, uint64 } }
338  static constexpr const char *TYPE_AS_STRING = "((tttt)(tttt)(tttt)(tttt))";
339 };
340 
341 template <> struct DBusTypeTrait<Nat64AddressMapping>
342 {
343  // struct of {
344  // uint64,
345  // array of uint8,
346  // array of uint8,
347  // uint32,
348  // struct of {
349  // struct of { uint64, uint64, uint64, uint64 }
350  // struct of { uint64, uint64, uint64, uint64 }
351  // struct of { uint64, uint64, uint64, uint64 }
352  // struct of { uint64, uint64, uint64, uint64 } } }
353  static constexpr const char *TYPE_AS_STRING = "(tayayu((tttt)(tttt)(tttt)(tttt)))";
354 };
355 
356 template <> struct DBusTypeTrait<std::vector<Nat64AddressMapping>>
357 {
358  // array of struct of {
359  // uint64,
360  // array of uint8,
361  // array of uint8,
362  // uint32,
363  // struct of {
364  // struct of { uint64, uint64, uint64, uint64 }
365  // struct of { uint64, uint64, uint64, uint64 }
366  // struct of { uint64, uint64, uint64, uint64 }
367  // struct of { uint64, uint64, uint64, uint64 } } }
368  static constexpr const char *TYPE_AS_STRING = "a(tayayu((tttt)(tttt)(tttt)(tttt)))";
369 };
370 
371 template <> struct DBusTypeTrait<Nat64ErrorCounters>
372 {
373  // struct of { struct of { uint64, uint64 }
374  // struct of { uint64, uint64 }
375  // struct of { uint64, uint64 }
376  // struct of { uint64, uint64 } }
377  static constexpr const char *TYPE_AS_STRING = "((tt)(tt)(tt)(tt))";
378 };
379 
380 template <> struct DBusTypeTrait<int8_t>
381 {
382  static constexpr int TYPE = DBUS_TYPE_BYTE;
383  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_BYTE_AS_STRING;
384 };
385 
386 template <> struct DBusTypeTrait<uint8_t>
387 {
388  static constexpr int TYPE = DBUS_TYPE_BYTE;
389  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_BYTE_AS_STRING;
390 };
391 
392 template <> struct DBusTypeTrait<uint16_t>
393 {
394  static constexpr int TYPE = DBUS_TYPE_UINT16;
395  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_UINT16_AS_STRING;
396 };
397 
398 template <> struct DBusTypeTrait<uint32_t>
399 {
400  static constexpr int TYPE = DBUS_TYPE_UINT32;
401  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_UINT32_AS_STRING;
402 };
403 
404 template <> struct DBusTypeTrait<uint64_t>
405 {
406  static constexpr int TYPE = DBUS_TYPE_UINT64;
407  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_UINT64_AS_STRING;
408 };
409 
410 template <> struct DBusTypeTrait<int16_t>
411 {
412  static constexpr int TYPE = DBUS_TYPE_INT16;
413  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_INT16_AS_STRING;
414 };
415 
416 template <> struct DBusTypeTrait<int32_t>
417 {
418  static constexpr int TYPE = DBUS_TYPE_INT32;
419  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_INT32_AS_STRING;
420 };
421 
422 template <> struct DBusTypeTrait<int64_t>
423 {
424  static constexpr int TYPE = DBUS_TYPE_INT64;
425  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_INT64_AS_STRING;
426 };
427 
428 template <> struct DBusTypeTrait<std::string>
429 {
430  static constexpr int TYPE = DBUS_TYPE_STRING;
431  static constexpr const char *TYPE_AS_STRING = DBUS_TYPE_STRING_AS_STRING;
432 };
433 
434 otbrError DBusMessageEncode(DBusMessageIter *aIter, bool aValue);
435 otbrError DBusMessageEncode(DBusMessageIter *aIter, int8_t aValue);
436 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::string &aValue);
437 otbrError DBusMessageEncode(DBusMessageIter *aIter, const char *aValue);
438 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<uint8_t> &aValue);
439 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<uint16_t> &aValue);
440 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<uint32_t> &aValue);
441 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<uint64_t> &aValue);
442 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<int16_t> &aValue);
443 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<int32_t> &aValue);
444 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<int64_t> &aValue);
445 otbrError DBusMessageExtract(DBusMessageIter *aIter, bool &aValue);
446 otbrError DBusMessageExtract(DBusMessageIter *aIter, int8_t &aValue);
447 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::string &aValue);
448 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<uint8_t> &aValue);
449 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<uint16_t> &aValue);
450 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<uint32_t> &aValue);
451 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<uint64_t> &aValue);
452 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<int16_t> &aValue);
453 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<int32_t> &aValue);
454 otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<int64_t> &aValue);
455 
456 template <typename T> otbrError DBusMessageExtract(DBusMessageIter *aIter, T &aValue)
457 {
458  otbrError error = OTBR_ERROR_DBUS;
459 
460  VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBusTypeTrait<T>::TYPE);
461  dbus_message_iter_get_basic(aIter, &aValue);
462  dbus_message_iter_next(aIter);
463  error = OTBR_ERROR_NONE;
464 
465 exit:
466  return error;
467 }
468 
469 template <typename T> otbrError DBusMessageExtract(DBusMessageIter *aIter, std::vector<T> &aValue)
470 {
471  otbrError error = OTBR_ERROR_NONE;
472  DBusMessageIter subIter;
473 
474  VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_ARRAY, error = OTBR_ERROR_DBUS);
475  dbus_message_iter_recurse(aIter, &subIter);
476 
477  aValue.clear();
478  while (dbus_message_iter_get_arg_type(&subIter) != DBUS_TYPE_INVALID)
479  {
480  T val;
481  SuccessOrExit(error = DBusMessageExtract(&subIter, val));
482  aValue.push_back(val);
483  }
484  dbus_message_iter_next(aIter);
485 
486 exit:
487  return error;
488 }
489 
490 template <typename T> otbrError DBusMessageExtractPrimitive(DBusMessageIter *aIter, std::vector<T> &aValue)
491 {
492  DBusMessageIter subIter;
493  otbrError error = OTBR_ERROR_NONE;
494  T * val;
495  int n;
496  int subtype;
497 
498  VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_ARRAY, error = OTBR_ERROR_DBUS);
499  dbus_message_iter_recurse(aIter, &subIter);
500 
501  subtype = dbus_message_iter_get_arg_type(&subIter);
502  if (subtype != DBUS_TYPE_INVALID)
503  {
504  VerifyOrExit(dbus_message_iter_get_arg_type(&subIter) == DBusTypeTrait<T>::TYPE, error = OTBR_ERROR_DBUS);
505  dbus_message_iter_get_fixed_array(&subIter, &val, &n);
506 
507  if (val != nullptr)
508  {
509  aValue = std::vector<T>(val, val + n);
510  }
511  }
512  dbus_message_iter_next(aIter);
513 
514 exit:
515  return error;
516 }
517 
518 template <typename T, size_t SIZE> otbrError DBusMessageExtract(DBusMessageIter *aIter, std::array<T, SIZE> &aValue)
519 {
520  DBusMessageIter subIter;
521  otbrError error = OTBR_ERROR_NONE;
522  T * val;
523  int n;
524  int subtype;
525 
526  VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_ARRAY, error = OTBR_ERROR_DBUS);
527  dbus_message_iter_recurse(aIter, &subIter);
528 
529  subtype = dbus_message_iter_get_arg_type(&subIter);
530  if (subtype != DBUS_TYPE_INVALID)
531  {
532  VerifyOrExit(dbus_message_iter_get_arg_type(&subIter) == DBusTypeTrait<T>::TYPE, error = OTBR_ERROR_DBUS);
533  dbus_message_iter_get_fixed_array(&subIter, &val, &n);
534  VerifyOrExit(n == SIZE, error = OTBR_ERROR_DBUS);
535 
536  if (val != nullptr)
537  {
538  std::copy(val, val + n, aValue.begin());
539  }
540  }
541  dbus_message_iter_next(aIter);
542 
543 exit:
544  return error;
545 }
546 
547 template <typename T> otbrError DBusMessageEncode(DBusMessageIter *aIter, T aValue)
548 {
549  otbrError error = OTBR_ERROR_NONE;
550  VerifyOrExit(dbus_message_iter_append_basic(aIter, DBusTypeTrait<T>::TYPE, &aValue), error = OTBR_ERROR_DBUS);
551 
552 exit:
553  return error;
554 }
555 
556 template <typename T> otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::vector<T> &aValue)
557 {
558  otbrError error = OTBR_ERROR_NONE;
559  DBusMessageIter subIter;
560 
561  VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_ARRAY, DBusTypeTrait<T>::TYPE_AS_STRING, &subIter),
562  error = OTBR_ERROR_DBUS);
563 
564  for (const auto &v : aValue)
565  {
566  SuccessOrExit(error = DBusMessageEncode(&subIter, v));
567  }
568 
569  VerifyOrExit(dbus_message_iter_close_container(aIter, &subIter), error = OTBR_ERROR_DBUS);
570 exit:
571  return error;
572 }
573 
574 template <typename T> otbrError DBusMessageEncodePrimitive(DBusMessageIter *aIter, const std::vector<T> &aValue)
575 {
576  DBusMessageIter subIter;
577  otbrError error = OTBR_ERROR_NONE;
578 
579  VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_ARRAY, DBusTypeTrait<T>::TYPE_AS_STRING, &subIter),
580  error = OTBR_ERROR_DBUS);
581 
582  if (!aValue.empty())
583  {
584  const T *buf = &aValue.front();
585 
586  VerifyOrExit(dbus_message_iter_append_fixed_array(&subIter, DBusTypeTrait<T>::TYPE, &buf,
587  static_cast<int>(aValue.size())),
588  error = OTBR_ERROR_DBUS);
589  }
590  VerifyOrExit(dbus_message_iter_close_container(aIter, &subIter), error = OTBR_ERROR_DBUS);
591 exit:
592  return error;
593 }
594 
595 template <typename T, size_t SIZE>
596 otbrError DBusMessageEncode(DBusMessageIter *aIter, const std::array<T, SIZE> &aValue)
597 {
598  DBusMessageIter subIter;
599  otbrError error = OTBR_ERROR_NONE;
600 
601  VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_ARRAY, DBusTypeTrait<T>::TYPE_AS_STRING, &subIter),
602  error = OTBR_ERROR_DBUS);
603 
604  if (!aValue.empty())
605  {
606  const T *buf = &aValue.front();
607 
608  VerifyOrExit(dbus_message_iter_append_fixed_array(&subIter, DBusTypeTrait<T>::TYPE, &buf,
609  static_cast<int>(aValue.size())),
610  error = OTBR_ERROR_DBUS);
611  }
612  VerifyOrExit(dbus_message_iter_close_container(aIter, &subIter), error = OTBR_ERROR_DBUS);
613 exit:
614  return error;
615 }
616 
617 template <size_t I, typename... FieldTypes> struct ElementType
618 {
619  using ValueType = typename std::tuple_element<I, std::tuple<FieldTypes...>>::type;
620  using NonconstValueType = typename std::remove_cv<ValueType>::type;
621  using RawValueType = typename std::remove_reference<NonconstValueType>::type;
622 };
623 
624 template <size_t I, size_t N, typename... FieldTypes> class DBusMessageIterFor
625 {
626 public:
627  static otbrError ConvertToTuple(DBusMessageIter *aIter, std::tuple<FieldTypes...> &aValues)
628  {
629  using RawValueType = typename ElementType<N - I, FieldTypes...>::RawValueType;
630  RawValueType &val = std::get<N - I>(aValues);
631  otbrError error = DBusMessageExtract(aIter, val);
632 
633  SuccessOrExit(error);
634  error = DBusMessageIterFor<I - 1, N, FieldTypes...>::ConvertToTuple(aIter, aValues);
635 
636  exit:
637  return error;
638  }
639 
640  static otbrError ConvertToDBusMessage(DBusMessageIter *aIter, const std::tuple<FieldTypes...> &aValues)
641  {
642  otbrError error = DBusMessageEncode(aIter, std::get<N - I>(aValues));
643 
644  SuccessOrExit(error);
645  error = DBusMessageIterFor<I - 1, N, FieldTypes...>::ConvertToDBusMessage(aIter, aValues);
646 
647  exit:
648  return error;
649  }
650 };
651 
652 template <> class DBusMessageIterFor<0, 0>
653 {
654 public:
655  static otbrError ConvertToTuple(DBusMessageIter *aIter, std::tuple<> &aValues)
656  {
657  OTBR_UNUSED_VARIABLE(aIter);
658  OTBR_UNUSED_VARIABLE(aValues);
659  return OTBR_ERROR_NONE;
660  }
661 
662  static otbrError ConvertToDBusMessage(DBusMessageIter *aIter, const std::tuple<> &aValues)
663  {
664  OTBR_UNUSED_VARIABLE(aIter);
665  OTBR_UNUSED_VARIABLE(aValues);
666  return OTBR_ERROR_NONE;
667  }
668 };
669 
670 template <size_t N, typename... FieldTypes> class DBusMessageIterFor<1, N, FieldTypes...>
671 {
672 public:
673  static otbrError ConvertToTuple(DBusMessageIter *aIter, std::tuple<FieldTypes...> &aValues)
674  {
675  using RawValueType = typename ElementType<N - 1, FieldTypes...>::RawValueType;
676  RawValueType &val = std::get<N - 1>(aValues);
677  otbrError error = DBusMessageExtract(aIter, val);
678 
679  return error;
680  }
681 
682  static otbrError ConvertToDBusMessage(DBusMessageIter *aIter, const std::tuple<FieldTypes...> &aValues)
683  {
684  otbrError error = DBusMessageEncode(aIter, std::get<N - 1>(aValues));
685 
686  return error;
687  }
688 };
689 
690 template <typename... FieldTypes>
691 otbrError ConvertToDBusMessage(DBusMessageIter *aIter, const std::tuple<FieldTypes...> &aValues)
692 {
693  return DBusMessageIterFor<sizeof...(FieldTypes), sizeof...(FieldTypes), FieldTypes...>::ConvertToDBusMessage(
694  aIter, aValues);
695 }
696 
697 template <typename... FieldTypes>
698 constexpr otbrError ConvertToTuple(DBusMessageIter *aIter, std::tuple<FieldTypes...> &aValues)
699 {
700  return DBusMessageIterFor<sizeof...(FieldTypes), sizeof...(FieldTypes), FieldTypes...>::ConvertToTuple(aIter,
701  aValues);
702 }
703 
713 template <typename ValueType> otbrError DBusMessageEncodeToVariant(DBusMessageIter *aIter, const ValueType &aValue)
714 {
715  otbrError error = OTBR_ERROR_NONE;
716  DBusMessageIter subIter;
717 
718  VerifyOrExit(
719  dbus_message_iter_open_container(aIter, DBUS_TYPE_VARIANT, DBusTypeTrait<ValueType>::TYPE_AS_STRING, &subIter),
720  error = OTBR_ERROR_DBUS);
721 
722  SuccessOrExit(error = DBusMessageEncode(&subIter, aValue));
723 
724  VerifyOrExit(dbus_message_iter_close_container(aIter, &subIter), error = OTBR_ERROR_DBUS);
725 
726 exit:
727  return error;
728 }
729 
739 template <typename ValueType> otbrError DBusMessageExtractFromVariant(DBusMessageIter *aIter, ValueType &aValue)
740 {
741  otbrError error = OTBR_ERROR_NONE;
742  DBusMessageIter subIter;
743 
744  VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_VARIANT, error = OTBR_ERROR_DBUS);
745  dbus_message_iter_recurse(aIter, &subIter);
746 
747  SuccessOrExit(error = DBusMessageExtract(&subIter, aValue));
748 
749 exit:
750  return error;
751 }
752 
762 template <typename... FieldTypes>
763 otbrError DBusMessageToTuple(DBusMessage &aMessage, std::tuple<FieldTypes...> &aValues)
764 {
765  otbrError error = OTBR_ERROR_NONE;
766  DBusMessageIter iter;
767 
768  VerifyOrExit(dbus_message_iter_init(&aMessage, &iter), error = OTBR_ERROR_DBUS);
769 
770  error = ConvertToTuple(&iter, aValues);
771 
772 exit:
773  return error;
774 }
775 
785 template <typename... FieldTypes>
786 otbrError TupleToDBusMessage(DBusMessage &aMessage, const std::tuple<FieldTypes...> &aValues)
787 {
788  DBusMessageIter iter;
789 
790  dbus_message_iter_init_append(&aMessage, &iter);
791  return ConvertToDBusMessage(&iter, aValues);
792 }
793 
803 template <typename... FieldTypes>
804 otbrError DBusMessageToTuple(UniqueDBusMessage const &aMessage, std::tuple<FieldTypes...> &aValues)
805 {
806  return DBusMessageToTuple(*aMessage.get(), aValues);
807 }
808 
809 bool IsDBusMessageEmpty(DBusMessage &aMessage);
810 
811 } // namespace DBus
812 } // namespace otbr
813 
814 #endif // DBUS_MESSAGE_HELPER_HPP_
otbr::DBus::DBusTypeTrait
Definition: dbus_message_helper.hpp:115
otbr::DBus::LinkModeConfig
Definition: types.hpp:79
SuccessOrExit
#define SuccessOrExit(aStatus)
Definition: code_utils.hpp:73
OTBR_ERROR_DBUS
@ OTBR_ERROR_DBUS
DBus error.
Definition: types.hpp:75
otbr::DBus::ChildInfo
Definition: types.hpp:472
otbr::DBus::SrpServerState
SrpServerState
Definition: types.hpp:524
otbr::DBus::ElementType
Definition: dbus_message_helper.hpp:617
otbr::DBus::Ip6Prefix
Definition: types.hpp:86
otbr::DBus::LeaderData
Definition: types.hpp:509
otbr::DBus::ChannelQuality
Definition: types.hpp:466
otbr::DBus::ExternalRoute
Definition: types.hpp:159
otbr::DBus::Nat64AddressMapping
Definition: types.hpp:668
otbr::DBus::DnssdCounters
Definition: types.hpp:571
otbr::DBus::DBusMessageToTuple
otbrError DBusMessageToTuple(DBusMessage &aMessage, std::tuple< FieldTypes... > &aValues)
Definition: dbus_message_helper.hpp:763
types.hpp
dbus_resources.hpp
otbr::DBus::IpCounters
Definition: types.hpp:458
otbr::DBus::SrpServerAddressMode
SrpServerAddressMode
Definition: types.hpp:531
otbr::DBus::DBusMessageEncodeToVariant
otbrError DBusMessageEncodeToVariant(DBusMessageIter *aIter, const ValueType &aValue)
Definition: dbus_message_helper.hpp:713
code_utils.hpp
otbr::DBus::OnMeshPrefix
Definition: types.hpp:96
otbr::DBus::EnergyScanResult
Definition: types.hpp:73
otbr::DBus::Nat64PacketCounters
Definition: types.hpp:654
otbr::DBus::RadioSpinelMetrics
Definition: types.hpp:583
otbr::DBus::TupleToDBusMessage
otbrError TupleToDBusMessage(DBusMessage &aMessage, const std::tuple< FieldTypes... > &aValues)
Definition: dbus_message_helper.hpp:786
otbr::DBus::ActiveScanResult
Definition: types.hpp:57
VerifyOrExit
#define VerifyOrExit(aCondition,...)
Definition: code_utils.hpp:110
otbr::DBus::Nat64ProtocolCounters
Definition: types.hpp:660
otbr::DBus::RadioCoexMetrics
Definition: types.hpp:603
OTBR_ERROR_NONE
@ OTBR_ERROR_NONE
No error.
Definition: types.hpp:72
otbr::DBus::Nat64ErrorCounters
Definition: types.hpp:678
otbr::MdnsTelemetryInfo
Definition: types.hpp:395
otbrError
otbrError
Definition: types.hpp:70
otbr::DBus::SrpServerInfo
Definition: types.hpp:537
otbr::DBus::DBusMessageIterFor
Definition: dbus_message_helper.hpp:624
otbr::DBus::NeighborInfo
Definition: types.hpp:491
otbr::DBus::DBusMessageExtractFromVariant
otbrError DBusMessageExtractFromVariant(DBusMessageIter *aIter, ValueType &aValue)
Definition: dbus_message_helper.hpp:739
otbr::DBus::RcpInterfaceMetrics
Definition: types.hpp:591
otbr::DBus::BorderRoutingCounters
Definition: types.hpp:626
otbr::DBus::Nat64ComponentState
Definition: types.hpp:640
otbr::DBus::TxtEntry
Definition: types.hpp:518
otbr::DBus::Nat64TrafficCounters
Definition: types.hpp:646
otbr::DBus::MacCounters
Definition: types.hpp:196
Generated by   doxygen 1.8.17