[dbus] Implement D-BUS API GetTrelInfo

Introduce D-BUS API GetTrelInfo to support getting TREL telemetry.

.github/workflows/build.yml

@@ -62,7 +62,7 @@ jobs:
       BUILD_TARGET: check
       OTBR_BUILD_TYPE: ${{ matrix.build_type }}
       OTBR_MDNS: ${{ matrix.mdns }}
-      OTBR_OPTIONS: "-DOTBR_SRP_ADVERTISING_PROXY=ON -DOTBR_BORDER_ROUTING=ON -DOTBR_NAT64=1 -DOTBR_SRP_SERVER_AUTO_ENABLE=OFF"
+      OTBR_OPTIONS: "-DOTBR_SRP_ADVERTISING_PROXY=ON -DOTBR_BORDER_ROUTING=ON -DOTBR_NAT64=1 -DOTBR_SRP_SERVER_AUTO_ENABLE=OFF, -DOTBR_TREL=ON"
       OTBR_COVERAGE: 1
     steps:
     - uses: actions/checkout@v4

src/dbus/client/thread_api_dbus.cpp

@@ -659,6 +659,11 @@ ClientError ThreadApiDBus::GetSrpServerInfo(SrpServerInfo &aSrpServerInfo)
     return GetProperty(OTBR_DBUS_PROPERTY_SRP_SERVER_INFO, aSrpServerInfo);
 }
 
+ClientError ThreadApiDBus::GetTrelInfo(TrelInfo &aTrelInfo)
+{
+    return GetProperty(OTBR_DBUS_PROPERTY_TREL_INFO, aTrelInfo);
+}
+
 ClientError ThreadApiDBus::GetMdnsTelemetryInfo(MdnsTelemetryInfo &aMdnsTelemetryInfo)
 {
     return GetProperty(OTBR_DBUS_PROPERTY_MDNS_TELEMETRY_INFO, aMdnsTelemetryInfo);

src/dbus/client/thread_api_dbus.hpp

@@ -769,6 +769,18 @@ class ThreadApiDBus
      */
     ClientError GetSrpServerInfo(SrpServerInfo &aSrpServerInfo);
 
+    /**
+     * This method gets the TREL information.
+     *
+     * @param[out] aTrelInfo  The TREL information.
+     *
+     * @retval ERROR_NONE  Successfully performed the dbus function call
+     * @retval ERROR_DBUS  dbus encode/decode error
+     * @retval ...         OpenThread defined error value otherwise
+     *
+     */
+    ClientError GetTrelInfo(TrelInfo &aTrelInfo);
+
     /**
      * This method gets the MDNS telemetry information.
      *

src/dbus/common/constants.hpp

@@ -97,6 +97,7 @@
 #define OTBR_DBUS_PROPERTY_FEATURE_FLAG_LIST_DATA "FeatureFlagListData"
 #define OTBR_DBUS_PROPERTY_RADIO_REGION "RadioRegion"
 #define OTBR_DBUS_PROPERTY_SRP_SERVER_INFO "SrpServerInfo"
+#define OTBR_DBUS_PROPERTY_TREL_INFO "TrelInfo"
 #define OTBR_DBUS_PROPERTY_DNSSD_COUNTERS "DnssdCounters"
 #define OTBR_DBUS_PROPERTY_OTBR_VERSION "OtbrVersion"
 #define OTBR_DBUS_PROPERTY_OT_HOST_VERSION "OtHostVersion"

src/dbus/common/dbus_message_helper.hpp

@@ -115,6 +115,10 @@ otbrError DBusMessageEncode(DBusMessageIter *aIter, const Nat64ErrorCounters &aC
 otbrError DBusMessageExtract(DBusMessageIter *aIter, Nat64ErrorCounters &aCounters);
 otbrError DBusMessageEncode(DBusMessageIter *aIter, const InfraLinkInfo &aInfraLinkInfo);
 otbrError DBusMessageExtract(DBusMessageIter *aIter, InfraLinkInfo &aInfraLinkInfo);
+otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo &aTrelInfo);
+otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo &aTrelInfo);
+otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo::TrelCounters &aCounters);
+otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo::TrelCounters &aCounters);
 
 template <typename T> struct DBusTypeTrait;
 
@@ -382,6 +386,21 @@ template <> struct DBusTypeTrait<Nat64ErrorCounters>
     static constexpr const char *TYPE_AS_STRING = "((tt)(tt)(tt)(tt))";
 };
 
+template <> struct DBusTypeTrait<TrelInfo>
+{
+    // struct of { bool,
+    //             uint16,
+    //             struct of {
+    //               uint64, uint64, uint64, uint64, uint64 } }
+    static constexpr const char *TYPE_AS_STRING = "(bq(ttttt))";
+};
+
+template <> struct DBusTypeTrait<TrelInfo::TrelCounters>
+{
+    // struct of { uint64, uint64, uint64, uint64, uint64 }
+    static constexpr const char *TYPE_AS_STRING = "(ttttt)";
+};
+
 template <> struct DBusTypeTrait<InfraLinkInfo>
 {
     // struct of { string, bool, bool, bool, uint32, uint32, uint32 }

src/dbus/common/dbus_message_helper_openthread.cpp

@@ -1194,5 +1194,69 @@ otbrError DBusMessageExtract(DBusMessageIter *aIter, InfraLinkInfo &aInfraLinkIn
     return error;
 }
 
+otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo &aTrelInfo)
+{
+    DBusMessageIter sub;
+    otbrError       error = OTBR_ERROR_NONE;
+
+    VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
+
+    SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mEnabled));
+    SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mNumTrelPeers));
+    SuccessOrExit(error = DBusMessageEncode(&sub, aTrelInfo.mTrelCounters));
+
+    VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
+exit:
+    return error;
+}
+
+otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo &aTrelInfo)
+{
+    DBusMessageIter sub;
+    otbrError       error = OTBR_ERROR_NONE;
+
+    dbus_message_iter_recurse(aIter, &sub);
+
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mEnabled));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mNumTrelPeers));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelInfo.mTrelCounters));
+
+    dbus_message_iter_next(aIter);
+exit:
+    return error;
+}
+
+otbrError DBusMessageEncode(DBusMessageIter *aIter, const TrelInfo::TrelCounters &aTrelCounters)
+{
+    DBusMessageIter sub;
+    otbrError       error = OTBR_ERROR_NONE;
+    auto            args  = std::tie(aTrelCounters.mTxPackets, aTrelCounters.mTxBytes, aTrelCounters.mRxPackets,
+                                     aTrelCounters.mRxBytes, aTrelCounters.mTxFailure);
+
+    VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
+    SuccessOrExit(error = ConvertToDBusMessage(&sub, args));
+    VerifyOrExit(dbus_message_iter_close_container(aIter, &sub) == true, error = OTBR_ERROR_DBUS);
+exit:
+    return error;
+}
+
+otbrError DBusMessageExtract(DBusMessageIter *aIter, TrelInfo::TrelCounters &aTrelCounters)
+{
+    DBusMessageIter sub;
+    otbrError       error = OTBR_ERROR_NONE;
+
+    dbus_message_iter_recurse(aIter, &sub);
+
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxPackets));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxBytes));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mRxPackets));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mRxBytes));
+    SuccessOrExit(error = DBusMessageExtract(&sub, aTrelCounters.mTxFailure));
+
+    dbus_message_iter_next(aIter);
+exit:
+    return error;
+}
+
 } // namespace DBus
 } // namespace otbr

src/dbus/common/types.hpp

@@ -703,6 +703,22 @@ struct InfraLinkInfo
     uint32_t    mGlobalUnicastAddresses; ///< The number of global unicast addresses on the infra network interface.
 };
 
+struct TrelInfo
+{
+    struct TrelCounters
+    {
+        uint64_t mTxPackets; ///< Number of packets transmitted through TREL.
+        uint64_t mTxBytes;   ///< Sum of size of packets transmitted through TREL.
+        uint64_t mRxPackets; ///< Number of packets received through TREL.
+        uint64_t mRxBytes;   ///< Sum of size of packets received through TREL.
+        uint64_t mTxFailure; ///< Number of packets transmission failures through TREL.
+    };
+
+    bool         mEnabled;      ///< Whether TREL is enabled.
+    u_int16_t    mNumTrelPeers; ///< The number of TREL peers.
+    TrelCounters mTrelCounters; ///< The TREL counters.
+};
+
 } // namespace DBus
 } // namespace otbr
 

src/dbus/server/dbus_thread_object.cpp

@@ -42,6 +42,7 @@
 #include <openthread/openthread-system.h>
 #include <openthread/srp_server.h>
 #include <openthread/thread_ftd.h>
+#include <openthread/trel.h>
 #include <openthread/platform/radio.h>
 
 #include "common/api_strings.hpp"
@@ -270,6 +271,8 @@ otbrError DBusThreadObject::Init(void)
                                std::bind(&DBusThreadObject::GetNat64Cidr, this, _1));
     RegisterGetPropertyHandler(OTBR_DBUS_THREAD_INTERFACE, OTBR_DBUS_PROPERTY_INFRA_LINK_INFO,
                                std::bind(&DBusThreadObject::GetInfraLinkInfo, this, _1));
+    RegisterGetPropertyHandler(OTBR_DBUS_THREAD_INTERFACE, OTBR_DBUS_PROPERTY_TREL_INFO,
+                               std::bind(&DBusThreadObject::GetTrelInfoHandler, this, _1));
     RegisterGetPropertyHandler(OTBR_DBUS_THREAD_INTERFACE, OTBR_DBUS_PROPERTY_DNS_UPSTREAM_QUERY_STATE,
                                std::bind(&DBusThreadObject::GetDnsUpstreamQueryState, this, _1));
     RegisterGetPropertyHandler(OTBR_DBUS_THREAD_INTERFACE, OTBR_DBUS_PROPERTY_TELEMETRY_DATA,
@@ -1407,6 +1410,35 @@ otError DBusThreadObject::GetDnssdCountersHandler(DBusMessageIter &aIter)
 #endif // OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
 }
 
+otError DBusThreadObject::GetTrelInfoHandler(DBusMessageIter &aIter)
+{
+#if OTBR_ENABLE_TREL
+    auto           threadHelper = mNcp->GetThreadHelper();
+    auto           instance     = threadHelper->GetInstance();
+    otError        error        = OT_ERROR_NONE;
+    TrelInfo       trelInfo;
+    otTrelCounters otTrelCounters = *otTrelGetCounters(instance);
+
+    trelInfo.mTrelCounters.mTxPackets = otTrelCounters.mTxPackets;
+    trelInfo.mTrelCounters.mTxBytes   = otTrelCounters.mTxBytes;
+    trelInfo.mTrelCounters.mRxPackets = otTrelCounters.mRxPackets;
+    trelInfo.mTrelCounters.mRxBytes   = otTrelCounters.mRxBytes;
+    trelInfo.mTrelCounters.mTxFailure = otTrelCounters.mTxFailure;
+
+    trelInfo.mNumTrelPeers = otTrelGetNumberOfPeers(instance);
+    trelInfo.mEnabled      = otTrelIsEnabled(instance);
+
+    VerifyOrExit(DBusMessageEncodeToVariant(&aIter, trelInfo) == OTBR_ERROR_NONE, error = OT_ERROR_INVALID_ARGS);
+
+exit:
+    return error;
+#else  // OTBR_ENABLE_TREL
+    OTBR_UNUSED_VARIABLE(aIter);
+
+    return OT_ERROR_NOT_IMPLEMENTED;
+#endif // OTBR_ENABLE_TREL
+}
+
 otError DBusThreadObject::GetTelemetryDataHandler(DBusMessageIter &aIter)
 {
 #if OTBR_ENABLE_TELEMETRY_DATA_API

src/dbus/server/dbus_thread_object.hpp

@@ -162,6 +162,7 @@ class DBusThreadObject : public DBusObject
     otError GetRadioSpinelMetricsHandler(DBusMessageIter &aIter);
     otError GetRcpInterfaceMetricsHandler(DBusMessageIter &aIter);
     otError GetUptimeHandler(DBusMessageIter &aIter);
+    otError GetTrelInfoHandler(DBusMessageIter &aIter);
     otError GetRadioCoexMetrics(DBusMessageIter &aIter);
     otError GetBorderRoutingCountersHandler(DBusMessageIter &aIter);
     otError GetNat64State(DBusMessageIter &aIter);

src/proto/thread_telemetry.proto

@@ -309,6 +309,25 @@ message TelemetryData {
     optional SrpServerResponseCounters response_counters = 6;
   }
 
+  message TrelPacketCounters {
+    optional int64 trel_frame_tx = 1;
+    optional int64 trel_bytes_tx = 2;
+    optional int64 trel_frame_rx = 3;
+    optional int64 trel_bytes_rx = 4;
+    optional int64 trel_frame_tx_failed = 5;
+  }
+
+  message TrelInfo {
+    // Whether TREL is enabled.
+    optional bool is_trel_enabled = 1;
+
+    // The number of trel peers.
+    optional uint32 num_trel_peers = 2;
+
+    // Trel packet counters
+    optional TrelPacketCounters counters = 3;
+  }
+
   message DnsServerResponseCounters {
     // The number of successful responses
     optional uint32 success_count = 1;

tests/dbus/test_dbus_client.cpp

@@ -54,6 +54,7 @@ using otbr::DBus::LinkModeConfig;
 using otbr::DBus::OnMeshPrefix;
 using otbr::DBus::SrpServerInfo;
 using otbr::DBus::ThreadApiDBus;
+using otbr::DBus::TrelInfo;
 using otbr::DBus::TxtEntry;
 
 #if OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
@@ -182,6 +183,20 @@ void CheckSrpServerInfo(ThreadApiDBus *aApi)
     TEST_ASSERT(srpServerInfo.mResponseCounters.mOther == 0);
 }
 
+void CheckTrelInfo(ThreadApiDBus *aApi)
+{
+    TrelInfo trelInfo;
+
+    TEST_ASSERT(aApi->GetTrelInfo(trelInfo) == OTBR_ERROR_NONE);
+    TEST_ASSERT(trelInfo.mEnabled);
+    TEST_ASSERT(trelInfo.mNumTrelPeers == 0);
+    TEST_ASSERT(trelInfo.mTrelCounters.mRxBytes == 0);
+    TEST_ASSERT(trelInfo.mTrelCounters.mRxPackets == 0);
+    TEST_ASSERT(trelInfo.mTrelCounters.mTxBytes == 0);
+    TEST_ASSERT(trelInfo.mTrelCounters.mTxPackets == 0);
+    TEST_ASSERT(trelInfo.mTrelCounters.mTxFailure == 0);
+}
+
 void CheckDnssdCounters(ThreadApiDBus *aApi)
 {
     OTBR_UNUSED_VARIABLE(aApi);
@@ -420,6 +435,7 @@ int main()
                             TEST_ASSERT(api->GetRadioTxPower(txPower) == OTBR_ERROR_NONE);
                             TEST_ASSERT(api->GetActiveDatasetTlvs(activeDataset) == OTBR_ERROR_NONE);
                             CheckSrpServerInfo(api.get());
+                            CheckTrelInfo(api.get());
                             CheckMdnsInfo(api.get());
                             CheckDnssdCounters(api.get());
                             CheckNat64(api.get());