Add operational resolution retries in OperationalSessionSetup. (#25991)

Apparently some border routers are broken and don't actually do the "multicast"
part of mDNS right, leading to resolve failures if the advertisement is not
available during the initial unicast-response probe.  Work around that by
retrying operational discovery a few times during commissioning.

src/app/OperationalSessionSetup.cpp

@@ -442,6 +442,10 @@ CHIP_ERROR OperationalSessionSetup::LookupPeerAddress()
  {
  ++mAttemptsDone;
  }
+ if (mResolveAttemptsAllowed > 0)
+ {
+ --mResolveAttemptsAllowed;
+ }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
 
  // NOTE: This is public API that can be used to update our stored peer
@@ -502,9 +506,44 @@ void OperationalSessionSetup::OnNodeAddressResolutionFailed(const PeerId & peerI
  ChipLogError(Discovery, "OperationalSessionSetup[%u:" ChipLogFormatX64 "]: operational discovery failed: %" CHIP_ERROR_FORMAT,
  mPeerId.GetFabricIndex(), ChipLogValueX64(mPeerId.GetNodeId()), reason.Format());
 
- // Does it make sense to ScheduleSessionSetupReattempt() here? DNS-SD
- // resolution has its own retry/backoff mechanisms, so if it's failed we
- // have already done a lot of that.
+#if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
+ // If we're in a mode where we would generally retry CASE, retry operational
+ // discovery once. That allows us to more-gracefully handle broken networks
+ // where multicast DNS does not actually work and hence only the initial
+ // unicast DNS-SD queries get a response.
+ //
+ // We check for State::ResolvingAddress just in case in the meantime
+ // something weird happened and we are no longer trying to resolve an
+ // address.
+ if (mState == State::ResolvingAddress && mResolveAttemptsAllowed > 0)
+ {
+ ChipLogProgress(Discovery, "Retrying operational DNS-SD discovery. Attempts remaining: %u", mResolveAttemptsAllowed);
+
+ // Pretend like our previous attempt (i.e. call to LookupPeerAddress)
+ // has not happened for purposes of the generic attempt counters, so we
+ // don't mess up the counters for our actual CASE retry logic.
+ if (mRemainingAttempts < UINT8_MAX)
+ {
+ ++mRemainingAttempts;
+ }
+ if (mAttemptsDone > 0)
+ {
+ --mAttemptsDone;
+ }
+
+ CHIP_ERROR err = LookupPeerAddress();
+ if (err == CHIP_NO_ERROR)
+ {
+ // We need to notify our consumer that the resolve will take more
+ // time, but we don't actually know how much time it will take,
+ // because the resolver does not expose that information. Just use
+ // one minute to be safe.
+ using namespace chip::System::Clock::Literals;
+ NotifyRetryHandlers(reason, 60_s16);
+ return;
+ }
+ }
+#endif
 
  // No need to modify any variables in `this` since call below releases `this`.
  DequeueConnectionCallbacks(reason);
@@ -531,6 +570,11 @@ void OperationalSessionSetup::UpdateAttemptCount(uint8_t attemptCount)
  {
  mRemainingAttempts = attemptCount;
  }
+
+ if (attemptCount > mResolveAttemptsAllowed)
+ {
+ mResolveAttemptsAllowed = attemptCount;
+ }
 }
 
 CHIP_ERROR OperationalSessionSetup::ScheduleSessionSetupReattempt(System::Clock::Seconds16 & timerDelay)
@@ -619,11 +663,16 @@ void OperationalSessionSetup::NotifyRetryHandlers(CHIP_ERROR error, const Reliab
  System::Clock::Timeout messageTimeout = CASESession::ComputeSigma1ResponseTimeout(remoteMrpConfig);
  auto timeoutSecs = std::chrono::duration_cast<System::Clock::Seconds16>(messageTimeout);
  // Add 1 second in case we had fractional milliseconds in messageTimeout.
- timeoutSecs += System::Clock::Seconds16(1);
+ using namespace chip::System::Clock::Literals;
+ NotifyRetryHandlers(error, timeoutSecs + 1_s16 + retryDelay);
+}
+
+void OperationalSessionSetup::NotifyRetryHandlers(CHIP_ERROR error, System::Clock::Seconds16 timeoutEstimate)
+{
  for (auto * item = mConnectionRetry.First(); item && item != &mConnectionRetry; item = item->mNext)
  {
  auto cb = Callback::Callback<OnDeviceConnectionRetry>::FromCancelable(item);
- cb->mCall(cb->mContext, mPeerId, error, timeoutSecs + retryDelay);
+ cb->mCall(cb->mContext, mPeerId, error, timeoutEstimate);
  }
 }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES

src/app/OperationalSessionSetup.h

@@ -286,6 +286,8 @@ class DLL_EXPORT OperationalSessionSetup : public SessionDelegate,
  uint8_t mRemainingAttempts = 0;
  uint8_t mAttemptsDone = 0;
 
+ uint8_t mResolveAttemptsAllowed = 0;
+
  Callback::CallbackDeque mConnectionRetry;
 #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
 
@@ -354,6 +356,12 @@ class DLL_EXPORT OperationalSessionSetup : public SessionDelegate,
  */
  void NotifyRetryHandlers(CHIP_ERROR error, const ReliableMessageProtocolConfig & remoteMrpConfig,
  System::Clock::Seconds16 retryDelay);
+
+ /**
+ * A version of NotifyRetryHandlers that passes in a retry timeout estimate
+ * directly.
+ */
+ void NotifyRetryHandlers(CHIP_ERROR error, System::Clock::Seconds16 timeoutEstimate);
 #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
 };