Making py chip-device-ctrl discoverable over DNS-SD as a commissioner

project-chip · Sep 10, 2021 · 4e1caad · 4e1caad
1 parent d05f16f
commit 4e1caad
Show file tree

Hide file tree

Showing 5 changed files with 49 additions and 10 deletions.
diff --git a/src/app/server/Mdns.cpp b/src/app/server/Mdns.cpp
@@ -20,7 +20,6 @@
 #include <inttypes.h>
 
 #include <core/Optional.h>
-#include <mdns/Advertiser.h>
 #include <mdns/ServiceNaming.h>
 #include <messaging/ReliableMessageProtocolConfig.h>
 #include <platform/CHIPDeviceLayer.h>
@@ -137,19 +136,15 @@ CHIP_ERROR AdvertiseOperational()
     return CHIP_NO_ERROR;
 }
 
-/// Overloaded utility method for commissioner and commissionable advertisement
-/// This method is used for both commissioner discovery and commissionable node discovery since
-/// they share many fields.
 ///   commissionableNode = true : advertise commissionable node
 ///   commissionableNode = false : advertise commissioner
-CHIP_ERROR Advertise(bool commissionableNode, CommissioningMode mode)
+CHIP_ERROR BuildCommissionAdvertisingParameters(bool commissionableNode, CommissioningMode mode,
+                                                chip::Mdns::CommissionAdvertisingParameters & advertiseParameters)
 {
     bool commissioningMode       = (mode != CommissioningMode::kDisabled);
     bool additionalCommissioning = (mode == CommissioningMode::kEnabledEnhanced);
 
-    auto advertiseParameters = chip::Mdns::CommissionAdvertisingParameters()
-                                   .SetPort(commissionableNode ? GetSecuredPort() : GetUnsecuredPort())
-                                   .EnableIpV4(true);
+    advertiseParameters.SetPort(commissionableNode ? GetSecuredPort() : GetUnsecuredPort()).EnableIpV4(true);
     advertiseParameters.SetCommissionAdvertiseMode(commissionableNode ? chip::Mdns::CommssionAdvertiseMode::kCommissionableNode
                                                                       : chip::Mdns::CommssionAdvertiseMode::kCommissioner);
 
@@ -246,7 +241,18 @@ CHIP_ERROR Advertise(bool commissionableNode, CommissioningMode mode)
             advertiseParameters.SetPairingInstr(chip::Optional<const char *>::Value(pairingInst));
         }
     }
+    return CHIP_NO_ERROR;
+}
 
+/// Overloaded utility method for commissioner and commissionable advertisement
+/// This method is used for both commissioner discovery and commissionable node discovery since
+/// they share many fields.
+///   commissionableNode = true : advertise commissionable node
+///   commissionableNode = false : advertise commissioner
+CHIP_ERROR Advertise(bool commissionableNode, CommissioningMode mode)
+{
+    auto advertiseParameters = chip::Mdns::CommissionAdvertisingParameters();
+    BuildCommissionAdvertisingParameters(commissionableNode, mode, advertiseParameters);
     auto & mdnsAdvertiser = chip::Mdns::ServiceAdvertiser::Instance();
 
     ChipLogProgress(Discovery, "Advertise commission parameter vendorID=%u productID=%u discriminator=%04u/%02u",

diff --git a/src/app/server/Mdns.h b/src/app/server/Mdns.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <core/CHIPError.h>
+#include <mdns/Advertiser.h>
 #include <stddef.h>
 
 namespace chip {
@@ -52,6 +53,9 @@ CHIP_ERROR AdvertiseCommissioner();
 /// Set MDNS commissionable node advertisement
 CHIP_ERROR AdvertiseCommissionableNode(CommissioningMode mode);
 
+CHIP_ERROR BuildCommissionAdvertisingParameters(bool commissionableNode, CommissioningMode mode,
+                                                chip::Mdns::CommissionAdvertisingParameters & advertiseParameters);
+
 /// (Re-)starts the minmdns server
 /// - if device has not yet been commissioned, then commissioning mode will show as enabled (CM=1, AC=0)
 /// - if device has been commissioned, then commissioning mode will reflect the state of mode argument

diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
@@ -763,6 +763,12 @@ CHIP_ERROR DeviceCommissioner::Init(CommissionerInitParams params)
 
     mUdcServer->SetInstanceNameResolver(this);
     mUdcServer->SetUserConfirmationProvider(this);
+
+    // Advertise as commissioner
+    if (mAdvertiseParameters != nullptr)
+    {
+        ReturnErrorOnFailure(chip::Mdns::ServiceAdvertiser::Instance().Advertise(*mAdvertiseParameters));
+    }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     return CHIP_NO_ERROR;
 }
@@ -1494,6 +1500,17 @@ CHIP_ERROR DeviceCommissioner::SetUdcListenPort(uint16_t listenPort)
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR DeviceCommissioner::SetCommissionAdvertisingParameters(chip::Mdns::CommissionAdvertisingParameters * advertiseParameters)
+{
+    if (mState == State::Initialized)
+    {
+        return CHIP_ERROR_INCORRECT_STATE;
+    }
+
+    mAdvertiseParameters = advertiseParameters;
+    return CHIP_NO_ERROR;
+}
+
 void DeviceCommissioner::FindCommissionableNode(char * instanceName)
 {
     Mdns::DiscoveryFilter filter(Mdns::DiscoveryFilterType::kInstanceName, instanceName);

diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h
@@ -38,6 +38,7 @@
 #include <core/CHIPTLV.h>
 #include <credentials/CHIPOperationalCredentials.h>
 #include <lib/support/Span.h>
+#include <mdns/Advertiser.h>
 #include <messaging/ExchangeMgr.h>
 #include <messaging/ExchangeMgrDelegate.h>
 #include <protocols/secure_channel/MessageCounterManager.h>
@@ -425,6 +426,8 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController,
      * Set port for User Directed Commissioning
      */
     CHIP_ERROR SetUdcListenPort(uint16_t listenPort);
+
+    CHIP_ERROR SetCommissionAdvertisingParameters(chip::Mdns::CommissionAdvertisingParameters * advertiseParameters);
 #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
 
     /**
@@ -606,8 +609,9 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController,
 #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable
     UserDirectedCommissioningServer * mUdcServer = nullptr;
     // mUdcTransportMgr is for insecure communication (ex. user directed commissioning)
-    DeviceTransportMgr * mUdcTransportMgr = nullptr;
-    uint16_t mUdcListenPort               = CHIP_UDC_PORT;
+    DeviceTransportMgr * mUdcTransportMgr                              = nullptr;
+    uint16_t mUdcListenPort                                            = CHIP_UDC_PORT;
+    chip::Mdns::CommissionAdvertisingParameters * mAdvertiseParameters = nullptr;
 #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
 
     void PersistDeviceList();

diff --git a/src/controller/python/ChipDeviceController-ScriptBinding.cpp b/src/controller/python/ChipDeviceController-ScriptBinding.cpp
@@ -48,6 +48,7 @@
 
 #include <app/CommandSender.h>
 #include <app/InteractionModelEngine.h>
+#include <app/server/Mdns.h>
 #include <controller/CHIPDevice.h>
 #include <controller/CHIPDeviceController.h>
 #include <controller/ExampleOperationalCredentialsIssuer.h>
@@ -210,6 +211,13 @@ ChipError::StorageType pychip_DeviceController_NewDeviceController(chip::Control
     initParams.controllerNOC                  = nocSpan;
 
     (*outDevCtrl)->SetUdpListenPort(CHIP_PORT + 1);
+#if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable
+    auto advertiseParameters = chip::Mdns::CommissionAdvertisingParameters();
+    chip::app::Mdns::BuildCommissionAdvertisingParameters(false, chip::app::Mdns::CommissioningMode::kDisabled,
+                                                          advertiseParameters);
+    (*outDevCtrl)->SetCommissionAdvertisingParameters(&advertiseParameters);
+#endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
+
     err = (*outDevCtrl)->Init(initParams);
     VerifyOrReturnError(err == CHIP_NO_ERROR, err.AsInteger());