Pick the DTLS handshake timeout based on the ICE RTT estimate

webrtc/p2p/base/dtlstransportchannel.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 16 matching lines @@
 
 // We don't pull the RTP constants from rtputils.h, to avoid a layer violation.
 static const size_t kDtlsRecordHeaderLen = 13;
 static const size_t kMaxDtlsPacketLen = 2048;
 static const size_t kMinRtpPacketLen = 12;
 
 // Maximum number of pending packets in the queue. Packets are read immediately
 // after they have been written, so a capacity of "1" is sufficient.
 static const size_t kMaxPendingPackets = 1;
 
+// Minimum and maximum values for the initial DTLS handshake timeout. We'll pick
+// an initial timeout based on ICE RTT estimates, but clamp it to this range.
+static const int kMinHandshakeTimeout = 50;
+static const int kMaxHandshakeTimeout = 3000;
+
 static bool IsDtlsPacket(const char* data, size_t len) {
   const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
   return (len >= kDtlsRecordHeaderLen && (u[0] > 19 && u[0] < 64));
 }
 static bool IsDtlsClientHelloPacket(const char* data, size_t len) {
   if (!IsDtlsPacket(data, len)) {
     return false;
   }
   const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
   return len > 17 && u[0] == 22 && u[13] == 1;
@@ skipping 549 matching lines @@
       set_dtls_state(DTLS_TRANSPORT_CLOSED);
     } else {
       LOG_J(LS_INFO, this) << "DTLS transport error, code=" << err;
       set_dtls_state(DTLS_TRANSPORT_FAILED);
     }
   }
 }
 
 void DtlsTransport::MaybeStartDtls() {
   if (dtls_ && ice_transport_->writable()) {
+    ConfigureHandshakeTimeout();
+
     if (dtls_->StartSSL()) {
       // This should never fail:
       // Because we are operating in a nonblocking mode and all
       // incoming packets come in via OnReadPacket(), which rejects
       // packets in this state, the incoming queue must be empty. We
       // ignore write errors, thus any errors must be because of
       // configuration and therefore are our fault.
       RTC_NOTREACHED() << "StartSSL failed.";
       LOG_J(LS_ERROR, this) << "Couldn't start DTLS handshake";
       set_dtls_state(DTLS_TRANSPORT_FAILED);
@@ skipping 70 matching lines @@
   LOG_J(LS_VERBOSE, this) << "set_dtls_state from:" << dtls_state_ << " to "
                           << state;
   dtls_state_ = state;
   SignalDtlsState(this, state);
 }
 
 void DtlsTransport::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
+void DtlsTransport::ConfigureHandshakeTimeout() {
+  RTC_DCHECK(dtls_);
+  rtc::Optional<int> rtt = ice_transport_->GetRttEstimate();

[Taylor Brandstetter, 2017/02/02 18:07:41]

If no round trips have occurred yet (which would happen with the "presume
TURN<->TURN connections will work" option), won't this return the max RTT, and
result in a configured timeout of 3 seconds?

[Taylor Brandstetter, 2017/02/02 18:13:31]

This is probably why the "EndToEndConnectionTimeWithTurnTurnPair" test is
failing:

"configuring DTLS handshake timeout 3000 based on ICE RTT 3000"

I guess that test ended up being useful after all.

[skvlad, 2017/02/02 22:19:33]

I've changed P2PTransportChannel->GetRttEstimate() to only use the RTT if there
is at least one sample.
Switching RTT to rtc::Optional() everywhere will change the existing behavior
for GetStats and many other places - which might be better done in a separate
CL.

+  if (rtt) {
+    // Limit the timeout to a reasonable range in case the ICE RTT takes
+    // extreme values.
+    int initial_timeout = std::max(kMinHandshakeTimeout,
+                                   std::min(kMaxHandshakeTimeout,
+                                            2 * (*rtt)));
+    LOG_J(LS_INFO, this) << "configuring DTLS handshake timeout "
+                         << initial_timeout << " based on ICE RTT " << *rtt;
+
+    dtls_->SetHandshakeTimeout(initial_timeout);
+  } else {
+    LOG_J(LS_INFO, this)
+        << "no RTT estimate - using default DTLS handshake timeout";
+  }
+}
+
+
 }  // namespace cricket