Exposing DTLS transport state from TransportChannel.

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 212 matching lines @@
     dtls_state_ = STATE_NONE;
     return true;
   }
 
   // At this point we know we are doing DTLS
   remote_fingerprint_value_ = remote_fingerprint_value.Pass();
   remote_fingerprint_algorithm_ = digest_alg;
 
   if (!SetupDtls()) {
     dtls_state_ = STATE_CLOSED;
+    set_dtls_transport_state(DTLS_TRANSPORT_FAILED);
     return false;
   }
 
   dtls_state_ = STATE_ACCEPTED;
   return true;
 }
 
 bool DtlsTransportChannelWrapper::GetRemoteSSLCertificate(
     rtc::SSLCertificate** cert) const {
-  if (!dtls_)
+  if (!dtls_) {
     return false;
+  }
 
   return dtls_->GetPeerCertificate(cert);
 }
 
 bool DtlsTransportChannelWrapper::SetupDtls() {
   StreamInterfaceChannel* downward = new StreamInterfaceChannel(channel_);
 
   dtls_.reset(rtc::SSLStreamAdapter::Create(downward));
   if (!dtls_) {
     LOG_J(LS_ERROR, this) << "Failed to create DTLS adapter.";
@@ skipping 25 matching lines @@
   } else {
     LOG_J(LS_INFO, this) << "Not using DTLS.";
   }
 
   LOG_J(LS_INFO, this) << "DTLS setup complete.";
   return true;
 }
 
 bool DtlsTransportChannelWrapper::SetSrtpCiphers(
     const std::vector<std::string>& ciphers) {
-  if (srtp_ciphers_ == ciphers)
+  if (srtp_ciphers_ == ciphers) {
     return true;
+  }
 
   if (dtls_state_ == STATE_STARTED) {
     LOG(LS_WARNING) << "Ignoring new SRTP ciphers while DTLS is negotiating";
     return true;
   }
 
   if (dtls_state_ == STATE_OPEN) {
     // We don't support DTLS renegotiation currently. If new set of srtp ciphers
     // are different than what's being used currently, we will not use it.
     // So for now, let's be happy (or sad) with a warning message.
@@ skipping 230 matching lines @@
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(dtls == dtls_.get());
   if (sig & rtc::SE_OPEN) {
     // This is the first time.
     LOG_J(LS_INFO, this) << "DTLS handshake complete.";
     if (dtls_->GetState() == rtc::SS_OPEN) {
       // The check for OPEN shouldn't be necessary but let's make
       // sure we don't accidentally frob the state if it's closed.
       dtls_state_ = STATE_OPEN;
       set_writable(true);
+      set_dtls_transport_state(DTLS_TRANSPORT_CONNECTED);
     }
   }
   if (sig & rtc::SE_READ) {
     char buf[kMaxDtlsPacketLen];
     size_t read;
     if (dtls_->Read(buf, sizeof(buf), &read, NULL) == rtc::SR_SUCCESS) {
       SignalReadPacket(this, buf, read, rtc::CreatePacketTime(0), 0);
     }
   }
   if (sig & rtc::SE_CLOSE) {
     ASSERT(sig == rtc::SE_CLOSE);  // SE_CLOSE should be by itself.
     if (!err) {
       LOG_J(LS_INFO, this) << "DTLS channel closed";
     } else {
       LOG_J(LS_INFO, this) << "DTLS channel error, code=" << err;
     }
     set_writable(false);
     dtls_state_ = STATE_CLOSED;
+    set_dtls_transport_state(err ? DTLS_TRANSPORT_FAILED
+                                 : DTLS_TRANSPORT_CLOSED);
   }
 }
 
 bool DtlsTransportChannelWrapper::MaybeStartDtls() {
   if (channel_->writable()) {
     if (dtls_->StartSSLWithPeer()) {
       LOG_J(LS_ERROR, this) << "Couldn't start DTLS handshake";
       dtls_state_ = STATE_CLOSED;
+      set_dtls_transport_state(DTLS_TRANSPORT_FAILED);
       return false;
     }
     LOG_J(LS_INFO, this)
       << "DtlsTransportChannelWrapper: Started DTLS handshake";
 
     dtls_state_ = STATE_STARTED;
+    set_dtls_transport_state(DTLS_TRANSPORT_CONNECTING);

[pthatcher1, 2015/10/20 20:28:06]

Please see if we can reduce down to one dtls_state_ instead of two.

[Taylor Brandstetter, 2015/10/21 16:28:16]

Done.

   }
   return true;
 }
 
 // Called from OnReadPacket when a DTLS packet is received.
 bool DtlsTransportChannelWrapper::HandleDtlsPacket(const char* data,
                                                    size_t size) {
   // Sanity check we're not passing junk that
   // just looks like DTLS.
   const uint8_t* tmp_data = reinterpret_cast<const uint8_t*>(data);
@@ skipping 40 matching lines @@
   SignalRouteChange(this, candidate);
 }
 
 void DtlsTransportChannelWrapper::OnConnectionRemoved(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalConnectionRemoved(this);
 }
 
 }  // namespace cricket