[ncp] bridge DNSSD TXT and address resolvers over Spinel

Discovery Proxy on NCP needs TXT and host address resolution from the
host OTBR, but only browse and SRV resolvers were wired through Spinel.
Add the missing properties, codecs, and NCP handlers so the platform
DNSSD stubs forward resolver start/stop and deliver results back.

- Add SPINEL_PROP_DNSSD_TXT_* and IP4/IP6 address resolver/result props
- Encode/decode TXT and address discovery in spinel_prop_codec
- Handle resolver insert/remove and result SET in ncp_base_ftd
- Wire otPlatDnssd*Txt/Address* stubs in ncp/platform/dnssd.cpp
- Fix DecodeDnssdHost for multiple address entries

Author: hemanth-silabs

src/lib/spinel/spinel.c

@@ -1423,6 +1423,12 @@ const char *spinel_prop_key_to_cstr(spinel_prop_key_t prop_key)
         {SPINEL_PROP_DNSSD_BROWSE_RESULT, "DNSSD_BROWSE_RESULT"},
         {SPINEL_PROP_DNSSD_SRV_RESOLVER, "DNSSD_SRV_RESOLVER"},
         {SPINEL_PROP_DNSSD_SRV_RESULT, "DNSSD_SRV_RESULT"},
+        {SPINEL_PROP_DNSSD_TXT_RESOLVER, "DNSSD_TXT_RESOLVER"},
+        {SPINEL_PROP_DNSSD_TXT_RESULT, "DNSSD_TXT_RESULT"},
+        {SPINEL_PROP_DNSSD_IP6_ADDRESS_RESOLVER, "DNSSD_IP6_ADDRESS_RESOLVER"},
+        {SPINEL_PROP_DNSSD_IP6_ADDRESS_RESULT, "DNSSD_IP6_ADDRESS_RESULT"},
+        {SPINEL_PROP_DNSSD_IP4_ADDRESS_RESOLVER, "DNSSD_IP4_ADDRESS_RESOLVER"},
+        {SPINEL_PROP_DNSSD_IP4_ADDRESS_RESULT, "DNSSD_IP4_ADDRESS_RESULT"},
         {SPINEL_PROP_BORDER_AGENT_MESHCOP_SERVICE_STATE, "BORDER_AGENT_MESHCOP_SERVICE_STATE"},
         {SPINEL_PROP_BORDER_AGENT_EPHEMERAL_KEY_STATE, "SPINEL_PROP_BORDER_AGENT_EPHEMERAL_KEY_STATE"},
         {SPINEL_PROP_BORDER_AGENT_EPHEMERAL_KEY_ENABLE, "SPINEL_PROP_BORDER_AGENT_EPHEMERAL_KEY_ENABLE"},

src/lib/spinel/spinel.h

@@ -4959,6 +4959,63 @@ enum
      */
     SPINEL_PROP_DNSSD_SRV_RESULT = SPINEL_PROP_DNSSD__BEGIN + 9,
 
+    /// DNS-SD TXT Resolver
+    /**
+     * Format: `UULD`: Inserted/Removed
+     *
+     * `U`: The service instance label.
+     * `U`: The service type.
+     * `L`: The infrastructure network interface index.
+     * `D`: The context of the request (pointer to `otPlatDnssdTxtCallback`).
+     */
+    SPINEL_PROP_DNSSD_TXT_RESOLVER = SPINEL_PROP_DNSSD__BEGIN + 10,
+
+    /// DNS-SD TXT Resolution Result
+    /**
+     * Format: `UUdLLD`: Set
+     *
+     * `U`: Service instance label.
+     * `U`: Service type.
+     * `d`: Encoded TXT data bytes (empty if removed).
+     * `L`: TTL in seconds (zero indicates removal).
+     * `L`: Infrastructure interface index.
+     * `D`: Callback context (`sizeof(otPlatDnssdTxtCallback)`).
+     */
+    SPINEL_PROP_DNSSD_TXT_RESULT = SPINEL_PROP_DNSSD__BEGIN + 11,
+
+    /// DNS-SD IPv6 Address Resolver
+    /**
+     * Format: `ULD`: Inserted/Removed
+     *
+     * `U`: Host name (no domain).
+     * `L`: Infrastructure interface index.
+     * `D`: Callback context (`sizeof(otPlatDnssdAddressCallback)`).
+     */
+    SPINEL_PROP_DNSSD_IP6_ADDRESS_RESOLVER = SPINEL_PROP_DNSSD__BEGIN + 12,
+
+    /// DNS-SD IPv6 Address Resolution Result
+    /**
+     * Format: `ULt(A(6)L)D`: Set
+     *
+     * `U`: Host name.
+     * `L`: Infrastructure interface index.
+     * `t(A(6)L)`: Array of (`A(6)` IPv6 address, `L` TTL) entries.
+     * `D`: Callback context (`sizeof(otPlatDnssdAddressCallback)`).
+     */
+    SPINEL_PROP_DNSSD_IP6_ADDRESS_RESULT = SPINEL_PROP_DNSSD__BEGIN + 13,
+
+    /// DNS-SD IPv4 Address Resolver
+    /**
+     * Format: `ULD`: Inserted/Removed (same as IPv6 resolver; IPv4 uses IPv4-mapped IPv6 in results).
+     */
+    SPINEL_PROP_DNSSD_IP4_ADDRESS_RESOLVER = SPINEL_PROP_DNSSD__BEGIN + 14,
+
+    /// DNS-SD IPv4 Address Resolution Result
+    /**
+     * Format: Same as `SPINEL_PROP_DNSSD_IP6_ADDRESS_RESULT`.
+     */
+    SPINEL_PROP_DNSSD_IP4_ADDRESS_RESULT = SPINEL_PROP_DNSSD__BEGIN + 15,
+
     SPINEL_PROP_DNSSD__END = 0x950,
 
     SPINEL_PROP_BORDER_AGENT__BEGIN = 0x950,

src/lib/spinel/spinel_prop_codec.cpp

@@ -124,7 +124,25 @@ otError DecodeDnssdHost(Decoder              &aDecoder,
 
     SuccessOrExit(error = aDecoder.ReadUtf8(aHost.mHostName));
     SuccessOrExit(error = aDecoder.ReadUint16(aHost.mAddressesLength));
-    SuccessOrExit(error = aDecoder.ReadIp6Address(aHost.mAddresses));
+
+    if (aHost.mAddressesLength > 0)
+    {
+        const otIp6Address *address = nullptr;
+
+        SuccessOrExit(error = aDecoder.ReadIp6Address(aHost.mAddresses));
+
+        for (uint16_t i = 1; i < aHost.mAddressesLength; i++)
+        {
+            SuccessOrExit(error = aDecoder.ReadIp6Address(address));
+        }
+
+        OT_UNUSED_VARIABLE(address);
+    }
+    else
+    {
+        aHost.mAddresses = nullptr;
+    }
+
     SuccessOrExit(error = aDecoder.ReadUint32(aRequestId));
     SuccessOrExit(error = aDecoder.ReadData(aCallbackData, aCallbackDataLen));
 
@@ -377,5 +395,159 @@ otError DecodeDnssdSrvResult(Decoder              &aDecoder,
     return error;
 }
 
+template <>
+otError EncodeDnssdDiscovery<otPlatDnssdTxtResolver>(Encoder &aEncoder, const otPlatDnssdTxtResolver &aDiscovery)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aEncoder.WriteUtf8(aDiscovery.mServiceInstance));
+    SuccessOrExit(error = aEncoder.WriteUtf8(aDiscovery.mServiceType));
+    SuccessOrExit(error = aEncoder.WriteUint32(aDiscovery.mInfraIfIndex));
+    SuccessOrExit(error = aEncoder.WriteData(reinterpret_cast<const uint8_t *>(&aDiscovery.mCallback),
+                                             sizeof(aDiscovery.mCallback)));
+
+exit:
+    return error;
+}
+
+template <>
+otError EncodeDnssdDiscovery<otPlatDnssdAddressResolver>(Encoder                          &aEncoder,
+                                                         const otPlatDnssdAddressResolver &aDiscovery)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aEncoder.WriteUtf8(aDiscovery.mHostName));
+    SuccessOrExit(error = aEncoder.WriteUint32(aDiscovery.mInfraIfIndex));
+    SuccessOrExit(error = aEncoder.WriteData(reinterpret_cast<const uint8_t *>(&aDiscovery.mCallback),
+                                             sizeof(aDiscovery.mCallback)));
+
+exit:
+    return error;
+}
+
+otError EncodeDnssdTxtResult(Encoder                    &aEncoder,
+                             const otPlatDnssdTxtResult &aTxtResult,
+                             const uint8_t              *aCallbackData,
+                             uint16_t                    aCallbackDataLen)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aEncoder.WriteUtf8(aTxtResult.mServiceInstance));
+    SuccessOrExit(error = aEncoder.WriteUtf8(aTxtResult.mServiceType));
+    if (aTxtResult.mTxtData != nullptr && aTxtResult.mTxtDataLength > 0)
+    {
+        SuccessOrExit(error = aEncoder.WriteDataWithLen(aTxtResult.mTxtData, aTxtResult.mTxtDataLength));
+    }
+    else
+    {
+        SuccessOrExit(error = aEncoder.WriteDataWithLen(nullptr, 0));
+    }
+    SuccessOrExit(error = aEncoder.WriteUint32(aTxtResult.mTtl));
+    SuccessOrExit(error = aEncoder.WriteUint32(aTxtResult.mInfraIfIndex));
+    SuccessOrExit(error = aEncoder.WriteData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
+otError DecodeDnssdTxtResolver(Decoder                &aDecoder,
+                               otPlatDnssdTxtResolver &aTxtResolver,
+                               const uint8_t         *&aCallbackData,
+                               uint16_t               &aCallbackDataLen)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aDecoder.ReadUtf8(aTxtResolver.mServiceInstance));
+    SuccessOrExit(error = aDecoder.ReadUtf8(aTxtResolver.mServiceType));
+    SuccessOrExit(error = aDecoder.ReadUint32(aTxtResolver.mInfraIfIndex));
+    SuccessOrExit(error = aDecoder.ReadData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
+otError DecodeDnssdTxtResult(Decoder              &aDecoder,
+                             otPlatDnssdTxtResult &aTxtResult,
+                             const uint8_t       *&aCallbackData,
+                             uint16_t             &aCallbackDataLen)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aDecoder.ReadUtf8(aTxtResult.mServiceInstance));
+    SuccessOrExit(error = aDecoder.ReadUtf8(aTxtResult.mServiceType));
+    SuccessOrExit(error = aDecoder.ReadDataWithLen(aTxtResult.mTxtData, aTxtResult.mTxtDataLength));
+    SuccessOrExit(error = aDecoder.ReadUint32(aTxtResult.mTtl));
+    SuccessOrExit(error = aDecoder.ReadUint32(aTxtResult.mInfraIfIndex));
+    SuccessOrExit(error = aDecoder.ReadData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
+otError EncodeDnssdAddressResult(Encoder                        &aEncoder,
+                                 const otPlatDnssdAddressResult &aAddressResult,
+                                 const uint8_t                  *aCallbackData,
+                                 uint16_t                        aCallbackDataLen)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aEncoder.WriteUtf8(aAddressResult.mHostName));
+    SuccessOrExit(error = aEncoder.WriteUint32(aAddressResult.mInfraIfIndex));
+    SuccessOrExit(error = aEncoder.WriteUint16(aAddressResult.mAddressesLength));
+    for (uint16_t i = 0; i < aAddressResult.mAddressesLength; i++)
+    {
+        SuccessOrExit(error = aEncoder.WriteIp6Address(aAddressResult.mAddresses[i].mAddress));
+        SuccessOrExit(error = aEncoder.WriteUint32(aAddressResult.mAddresses[i].mTtl));
+    }
+    SuccessOrExit(error = aEncoder.WriteData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
+otError DecodeDnssdAddressResolver(Decoder                    &aDecoder,
+                                   otPlatDnssdAddressResolver &aAddressResolver,
+                                   const uint8_t             *&aCallbackData,
+                                   uint16_t                   &aCallbackDataLen)
+{
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = aDecoder.ReadUtf8(aAddressResolver.mHostName));
+    SuccessOrExit(error = aDecoder.ReadUint32(aAddressResolver.mInfraIfIndex));
+    SuccessOrExit(error = aDecoder.ReadData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
+otError DecodeDnssdAddressResult(Decoder                  &aDecoder,
+                                 otPlatDnssdAddressResult &aAddressResult,
+                                 otPlatDnssdAddressAndTtl *aAddressArray,
+                                 uint16_t                  aMaxAddresses,
+                                 const uint8_t           *&aCallbackData,
+                                 uint16_t                 &aCallbackDataLen)
+{
+    otError  error = OT_ERROR_NONE;
+    uint16_t count;
+
+    SuccessOrExit(error = aDecoder.ReadUtf8(aAddressResult.mHostName));
+    SuccessOrExit(error = aDecoder.ReadUint32(aAddressResult.mInfraIfIndex));
+    SuccessOrExit(error = aDecoder.ReadUint16(count));
+    VerifyOrExit(count <= aMaxAddresses, error = OT_ERROR_PARSE);
+
+    for (uint16_t i = 0; i < count; i++)
+    {
+        SuccessOrExit(error = aDecoder.ReadIp6Address(aAddressArray[i].mAddress));
+        SuccessOrExit(error = aDecoder.ReadUint32(aAddressArray[i].mTtl));
+    }
+
+    aAddressResult.mAddresses       = (count > 0) ? aAddressArray : nullptr;
+    aAddressResult.mAddressesLength = count;
+    SuccessOrExit(error = aDecoder.ReadData(aCallbackData, aCallbackDataLen));
+
+exit:
+    return error;
+}
+
 } // namespace Spinel
 } // namespace ot

src/lib/spinel/spinel_prop_codec.hpp

@@ -210,6 +210,90 @@ otError DecodeDnssdSrvResult(Decoder              &aDecoder,
                              otPlatDnssdSrvResult &aSrvResult,
                              const uint8_t       *&aCallbackData,
                              uint16_t             &aCallbackDataLen);
+
+/**
+ * Use Spinel::Encode to encode a Dnssd TXT result.
+ *
+ * @param[in] aEncoder          A reference to the encoder object.
+ * @param[in] aTxtResult        A reference to the TXT result.
+ * @param[in] aCallbackData     A pointer to the callback data.
+ * @param[in] aCallbackDataLen  The data length.
+ */
+otError EncodeDnssdTxtResult(Encoder                    &aEncoder,
+                             const otPlatDnssdTxtResult &aTxtResult,
+                             const uint8_t              *aCallbackData,
+                             uint16_t                    aCallbackDataLen);
+
+/**
+ * Use Spinel::Decoder to decode a SPINEL_PROP_DNSSD_TXT_RESOLVER message to a otPlatDnssdTxtResolver.
+ *
+ * @param[in]  aDecoder          A reference to the decoder object.
+ * @param[out] aTxtResolver      A reference to the TXT resolver.
+ * @param[out] aCallbackData     A reference to the pointer to the callback data.
+ * @param[out] aCallbackDataLen  A reference to the callback data length.
+ */
+otError DecodeDnssdTxtResolver(Decoder                &aDecoder,
+                               otPlatDnssdTxtResolver &aTxtResolver,
+                               const uint8_t         *&aCallbackData,
+                               uint16_t               &aCallbackDataLen);
+
+/**
+ * Use Spinel::Decoder to decode a SPINEL_PROP_DNSSD_TXT_RESULT message to a otPlatDnssdTxtResult.
+ *
+ * @param[in]  aDecoder          A reference to the decoder object.
+ * @param[out] aTxtResult        A reference to the TXT result.
+ * @param[out] aCallbackData     A reference to the pointer to the callback data.
+ * @param[out] aCallbackDataLen  A reference to the callback data length.
+ */
+otError DecodeDnssdTxtResult(Decoder              &aDecoder,
+                             otPlatDnssdTxtResult &aTxtResult,
+                             const uint8_t       *&aCallbackData,
+                             uint16_t             &aCallbackDataLen);
+
+/**
+ * Use Spinel::Encode to encode a Dnssd Address result.
+ *
+ * @param[in] aEncoder          A reference to the encoder object.
+ * @param[in] aAddressResult    A reference to the Address result.
+ * @param[in] aCallbackData     A pointer to the callback data.
+ * @param[in] aCallbackDataLen  The data length.
+ */
+otError EncodeDnssdAddressResult(Encoder                        &aEncoder,
+                                 const otPlatDnssdAddressResult &aAddressResult,
+                                 const uint8_t                  *aCallbackData,
+                                 uint16_t                        aCallbackDataLen);
+
+/**
+ * Use Spinel::Decoder to decode a SPINEL_PROP_DNSSD_IP6_ADDRESS_RESOLVER message to a otPlatDnssdAddressResolver.
+ *
+ * @param[in]  aDecoder          A reference to the decoder object.
+ * @param[out] aAddressResolver  A reference to the Address resolver.
+ * @param[out] aCallbackData     A reference to the pointer to the callback data.
+ * @param[out] aCallbackDataLen  A reference to the callback data length.
+ */
+otError DecodeDnssdAddressResolver(Decoder                    &aDecoder,
+                                   otPlatDnssdAddressResolver &aAddressResolver,
+                                   const uint8_t             *&aCallbackData,
+                                   uint16_t                   &aCallbackDataLen);
+
+/**
+ * Use Spinel::Decoder to decode a SPINEL_PROP_DNSSD_IP6_ADDRESS_RESULT message to a otPlatDnssdAddressResult.
+ *
+ * Also used for `SPINEL_PROP_DNSSD_IP4_ADDRESS_RESULT` (same wire format, IPv4 uses IPv4-mapped IPv6 address).
+ *
+ * @param[in]  aDecoder          A reference to the decoder object.
+ * @param[out] aAddressResult    A reference to the Address result.
+ * @param[out] aAddressArray     Caller-provided storage to copy address and TTL entries.
+ * @param[in]  aMaxAddresses     The maximum number of addresses.
+ * @param[out] aCallbackData     A reference to the pointer to the callback data.
+ * @param[out] aCallbackDataLen  A reference to the callback data length.
+ */
+otError DecodeDnssdAddressResult(Decoder                  &aDecoder,
+                                 otPlatDnssdAddressResult &aAddressResult,
+                                 otPlatDnssdAddressAndTtl *aAddressArray,
+                                 uint16_t                  aMaxAddresses,
+                                 const uint8_t           *&aCallbackData,
+                                 uint16_t                 &aCallbackDataLen);
 } // namespace Spinel
 } // namespace ot