[dnssd] support generic record queries via discovery proxy and SRP (openthread#11357)

This commit enhances the OpenThread DNSSD name server/resolver and its
native Discovery Proxy to support queries for arbitrary record
types.

To enable this, a new set of `otPlatDnssd` APIs are introduced for
generic `RecordQuerier`. These APIs mirror the existing APIs in the
OpenThread native mDNS module, allowing direct use of the native mDNS
implementation.

The discovery proxy implementation is updated to start and stop the
mDNS `RecordQuerier` when receiving a query for an arbitrary record
type, passing the first response record back to the client.

The unit tests `test_dnssd_discovery_proxy` and `test_dns_client`
are updated to cover all the newly added behaviors in discovery proxy.

Author: abtink

examples/platforms/simulation/dnssd.c

@@ -164,4 +164,16 @@ void otPlatDnssdStopIp4AddressResolver(otInstance *aInstance, const otPlatDnssdA
     OT_UNUSED_VARIABLE(aResolver);
 }
 
+void otPlatDnssdStartRecordQuerier(otInstance *aInstance, const otPlatDnssdRecordQuerier *aQuerier)
+{
+    OT_UNUSED_VARIABLE(aInstance);
+    OT_UNUSED_VARIABLE(aQuerier);
+}
+
+void otPlatDnssdStopRecordQuerier(otInstance *aInstance, const otPlatDnssdRecordQuerier *aQuerier)
+{
+    OT_UNUSED_VARIABLE(aInstance);
+    OT_UNUSED_VARIABLE(aQuerier);
+}
+
 #endif // OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE && OPENTHREAD_SIMULATION_IMPLEMENT_DNSSD

include/openthread/instance.h

@@ -52,7 +52,7 @@ extern "C" {
  *
  * @note This number versions both OpenThread platform and user APIs.
  */
-#define OPENTHREAD_API_VERSION (500)
+#define OPENTHREAD_API_VERSION (501)
 
 /**
  * @addtogroup api-instance

include/openthread/mdns.h

@@ -612,36 +612,17 @@ typedef otPlatDnssdAddressResult otMdnsAddressResult;
 /**
  * Represents a record query result.
  */
-typedef struct otMdnsRecordResult
-{
-    const char    *mFirstLabel;       ///< The first label of the name to be queried.
-    const char    *mNextLabels;       ///< The rest of the name labels. Does not include domain name. Can be NULL.
-    uint16_t       mRecordType;       ///< The record type.
-    const uint8_t *mRecordData;       ///< The record data bytes.
-    uint16_t       mRecordDataLength; ///< Number of bytes in record data.
-    uint32_t       mTtl;              ///< TTL in seconds. Zero TTL indicates removal the data.
-    uint32_t       mInfraIfIndex;     ///< The infrastructure network interface index.
-} otMdnsRecordResult;
+typedef otPlatDnssdRecordResult otMdnsRecordResult;
 
 /**
  * Represents the callback function used to report a record querier result.
- *
- * @param[in] aInstance    The OpenThread instance.
- * @param[in] aResult      The record querier result.
  */
-typedef void (*otMdnsRecordCallback)(otInstance *aInstance, const otMdnsRecordResult *aResult);
+typedef otPlatDnssdRecordCallback otMdnsRecordCallback;
 
 /**
  * Represents a record querier.
  */
-typedef struct otMdnsRecordQuerier
-{
-    const char          *mFirstLabel;   ///< The first label of the name to be queried. MUST NOT be NULL.
-    const char          *mNextLabels;   ///< The rest of name labels, excluding domain name. Can be NULL.
-    uint16_t             mRecordType;   ///< The record type to query.
-    uint32_t             mInfraIfIndex; ///< The infrastructure network interface index.
-    otMdnsRecordCallback mCallback;     ///< The callback to report result.
-} otMdnsRecordQuerier;
+typedef otPlatDnssdRecordQuerier otMdnsRecordQuerier;
 
 /**
  * Starts a service browser.

include/openthread/platform/dnssd.h

@@ -539,6 +539,40 @@ typedef struct otPlatDnssdAddressResolver
     otPlatDnssdAddressCallback mCallback;     ///< The callback to report result.
 } otPlatDnssdAddressResolver;
 
+/**
+ * Represents a record query result.
+ */
+typedef struct otPlatDnssdRecordResult
+{
+    const char    *mFirstLabel;       ///< The first label of the name to be queried.
+    const char    *mNextLabels;       ///< The rest of the name labels. Does not include domain name. Can be NULL.
+    uint16_t       mRecordType;       ///< The record type.
+    const uint8_t *mRecordData;       ///< The record data bytes.
+    uint16_t       mRecordDataLength; ///< Number of bytes in record data.
+    uint32_t       mTtl;              ///< TTL in seconds. Zero TTL indicates removal the data.
+    uint32_t       mInfraIfIndex;     ///< The infrastructure network interface index.
+} otPlatDnssdRecordResult;
+
+/**
+ * Represents the callback function used to report a record querier result.
+ *
+ * @param[in] aInstance    The OpenThread instance.
+ * @param[in] aResult      The record querier result.
+ */
+typedef void (*otPlatDnssdRecordCallback)(otInstance *aInstance, const otPlatDnssdRecordResult *aResult);
+
+/**
+ * Represents a record querier.
+ */
+typedef struct otPlatDnssdRecordQuerier
+{
+    const char               *mFirstLabel;   ///< The first label of the name to be queried. MUST NOT be NULL.
+    const char               *mNextLabels;   ///< The rest of name labels, excluding domain name. Can be NULL.
+    uint16_t                  mRecordType;   ///< The record type to query.
+    uint32_t                  mInfraIfIndex; ///< The infrastructure network interface index.
+    otPlatDnssdRecordCallback mCallback;     ///< The callback to report result.
+} otPlatDnssdRecordQuerier;
+
 /**
  * Starts a service browser.
  *
@@ -718,6 +752,46 @@ void otPlatDnssdStartIp4AddressResolver(otInstance *aInstance, const otPlatDnssd
  */
 void otPlatDnssdStopIp4AddressResolver(otInstance *aInstance, const otPlatDnssdAddressResolver *aResolver);
 
+/**
+ * Starts a record querier.
+ *
+ * Initiates a continuous query for a given `mRecordType` as specified in @p aQuerier. The queried name is specified
+ * by the combination of `mFirstLabel` and `mNextLabels` (optional rest of the labels) in @p aQuerier. The
+ * `mFirstLabel` is always non-NULL but `mNextLabels` can be `NULL` if there are no other labels. The `mNextLabels
+ * does not include the domain name. The reason for a separate first label is to allow it to include a dot `.`
+ * character (as allowed for service instance labels).
+ *
+ * Discovered results should be reported through the `mCallback` function in @p aQuerier, providing the raw record
+ * data bytes. A removed record data is indicated with a TTL value of zero. The callback may be invoked immediately
+ * with cached information (if available) and potentially before this function returns. When cached results are used,
+ * the reported TTL value should reflect the original TTL from the last received response.
+ *
+ * Multiple querier instances can be started for the same name, provided they use different callback functions.
+ *
+ * OpenThread will only use a record querier for types other than PTR, SRV, TXT, A, and AAAA. For those, specific
+ * browsers or resolvers are used. The platform implementation, therefore, can choose to restrict its implementation.
+ *
+ * The @p aQuerier and all its contained information (strings) are only valid during this call. The platform MUST save
+ * a copy of the information if it wants to retain the information after returning from this function.
+ *
+ * @param[in] aInstance   The OpenThread instance.
+ * @param[in] aQuerier    The record querier to be started.
+ */
+void otPlatDnssdStartRecordQuerier(otInstance *aInstance, const otPlatDnssdRecordQuerier *aQuerier);
+
+/**
+ * Stops a record querier.
+ *
+ * No action is performed if no matching querier with the same name, record type and callback is currently active.
+ *
+ * The @p aQuerier and all its contained information (strings) are only valid during this call. The platform MUST save
+ * a copy of the information if it wants to retain the information after returning from this function.
+ *
+ * @param[in] aInstance   The OpenThread instance.
+ * @param[in] aQuerier    The record querier to be stopped.
+ */
+void otPlatDnssdStopRecordQuerier(otInstance *aInstance, const otPlatDnssdRecordQuerier *aQuerier);
+
 /**
  * @}
  */

src/core/net/dns_types.cpp

@@ -1131,6 +1131,32 @@ Error ResourceRecord::DecompressRecordData(const Message &aMessage, uint16_t aOf
     return error;
 }
 
+ResourceRecord::TypeInfoString ResourceRecord::TypeToString(uint16_t aRecordType)
+{
+    static constexpr Stringify::Entry kRecordTypeTable[] = {
+        {kTypeA, "A"},     {kTypeNs, "NS"},       {kTypeCname, "CNAME"}, {kTypeSoa, "SOA"},     {kTypePtr, "PTR"},
+        {kTypeMx, "MX"},   {kTypeTxt, "TXT"},     {kTypeRp, "RP"},       {kTypeAfsdb, "AFSDB"}, {kTypeRt, "RT"},
+        {kTypeSig, "SIG"}, {kTypeKey, "KEY"},     {kTypePx, "PX"},       {kTypeAaaa, "AAAA"},   {kTypeSrv, "SRV"},
+        {kTypeKx, "KX"},   {kTypeDname, "DNAME"}, {kTypeOpt, "OPT"},     {kTypeNsec, "NSEC"},   {kTypeAny, "ANY"},
+    };
+
+    static_assert(Stringify::IsSorted(kRecordTypeTable), "kRecordTypeTable is not sorted");
+
+    TypeInfoString string;
+    const char    *lookupResult = Stringify::Lookup(aRecordType, kRecordTypeTable, nullptr);
+
+    if (lookupResult != nullptr)
+    {
+        string.Append("%s", lookupResult);
+    }
+    else
+    {
+        string.Append("RR:%u", aRecordType);
+    }
+
+    return string;
+}
+
 void TxtEntry::Iterator::Init(const uint8_t *aTxtData, uint16_t aTxtDataLength)
 {
     SetTxtData(aTxtData);

src/core/net/dns_types.hpp

@@ -46,6 +46,7 @@
 #include "common/equatable.hpp"
 #include "common/message.hpp"
 #include "common/owned_ptr.hpp"
+#include "common/string.hpp"
 #include "crypto/ecdsa.hpp"
 #include "net/ip4_types.hpp"
 #include "net/ip6_address.hpp"
@@ -1293,6 +1294,10 @@ class ResourceRecord
     static constexpr uint16_t kClassNone     = 254; ///< Class code None (NONE) - RFC 2136.
     static constexpr uint16_t kClassAny      = 255; ///< Class code Any (ANY).
 
+    static constexpr uint16_t kTypeStringSize = 17; ///< Size of `TypeInfoString`.
+
+    typedef String<kTypeStringSize> TypeInfoString; /// A string to represent a resource record type (human-readable).
+
     /**
      * Initializes the resource record by setting its type and class.
      *
@@ -1545,6 +1550,15 @@ class ResourceRecord
      */
     static Error DecompressRecordData(const Message &aMessage, uint16_t aOffset, OwnedPtr<Message> &aDataMsg);
 
+    /**
+     * Returns a human-readable string representation of a given resource record type.
+     *
+     * @param[in] aRecordType  The resource record type to convert.
+     *
+     * @returns human-readable string representation of a given resource record type.
+     */
+    static TypeInfoString TypeToString(uint16_t aRecordType);
+
 protected:
     Error ReadName(const Message &aMessage,
                    uint16_t      &aOffset,

src/core/net/dnssd.cpp

@@ -473,6 +473,50 @@ void Dnssd::StopIp4AddressResolver(const AddressResolver &aResolver)
     return;
 }
 
+void Dnssd::StartRecordQuerier(const RecordQuerier &aQuerier)
+{
+    VerifyOrExit(IsReady());
+
+#if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
+    if (mUseNativeMdns)
+#endif
+#if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
+    {
+        IgnoreError(Get<Dns::Multicast::Core>().StartRecordQuerier(aQuerier));
+        ExitNow();
+    }
+#endif
+
+#if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
+    otPlatDnssdStartRecordQuerier(&GetInstance(), &aQuerier);
+#endif
+
+exit:
+    return;
+}
+
+void Dnssd::StopRecordQuerier(const RecordQuerier &aQuerier)
+{
+    VerifyOrExit(IsReady());
+
+#if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
+    if (mUseNativeMdns)
+#endif
+#if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
+    {
+        IgnoreError(Get<Dns::Multicast::Core>().StopRecordQuerier(aQuerier));
+        ExitNow();
+    }
+#endif
+
+#if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
+    otPlatDnssdStopRecordQuerier(&GetInstance(), &aQuerier);
+#endif
+
+exit:
+    return;
+}
+
 void Dnssd::HandleStateChange(void)
 {
 #if OPENTHREAD_CONFIG_SRP_SERVER_ADVERTISING_PROXY_ENABLE

src/core/net/dnssd.hpp

@@ -93,12 +93,14 @@ class Dnssd : public InstanceLocator, private NonCopyable
     typedef otPlatDnssdBrowseCallback   BrowseCallback;   ///< Browser callback.
     typedef otPlatDnssdSrvCallback      SrvCallback;      ///< SRV callback.
     typedef otPlatDnssdTxtCallback      TxtCallback;      ///< TXT callback.
-    typedef otPlatDnssdAddressCallback  AddressCallback;  ///< Address callback
+    typedef otPlatDnssdAddressCallback  AddressCallback;  ///< Address callback.
+    typedef otPlatDnssdRecordCallback   RecordCallback;   ///< Record callback.
     typedef otPlatDnssdBrowseResult     BrowseResult;     ///< Browser result.
     typedef otPlatDnssdSrvResult        SrvResult;        ///< SRV result.
     typedef otPlatDnssdTxtResult        TxtResult;        ///< TXT result.
     typedef otPlatDnssdAddressResult    AddressResult;    ///< Address result.
     typedef otPlatDnssdAddressAndTtl    AddressAndTtl;    ///< Address and TTL.
+    typedef otPlatDnssdRecordResult     RecordResult;     ///< Record result.
 
     class Host : public otPlatDnssdHost, public Clearable<Host> ///< Host information.
     {
@@ -128,6 +130,10 @@ class Dnssd : public InstanceLocator, private NonCopyable
     {
     };
 
+    class RecordQuerier : public otPlatDnssdRecordQuerier, public Clearable<RecordQuerier> ///< Record querier.
+    {
+    };
+
     /**
      * Represents a range of `RequestId` values.
      *
@@ -381,6 +387,26 @@ class Dnssd : public InstanceLocator, private NonCopyable
      */
     void StopIp4AddressResolver(const AddressResolver &aResolver);
 
+    /**
+     * Starts a record querier.
+     *
+     * Refer to the documentation for `otPlatDnssdStartRecordQuerier()` for a more detailed description of the
+     * behavior of this method.
+     *
+     * @param[in] aQuerier    The querier to be started.
+     */
+    void StartRecordQuerier(const RecordQuerier &aQuerier);
+
+    /**
+     * Stops a record querier.
+     *
+     * Refer to the documentation for `otPlatDnssdStopRecordQuerier()` for a more detailed description of the
+     * behavior of this method.
+     *
+     * @param[in] aQuerier    The querier to stop.
+     */
+    void StopRecordQuerier(const RecordQuerier &aQuerier);
+
 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
     /**
      * Handles native mDNS state change.