Cache a ClientHello received before the DTLS handshake has started.

webrtc/p2p/base/faketransportcontroller.h

 /*
  *  Copyright 2009 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 123 matching lines @@
       if (dest_) {
         dest_->state_ = STATE_INIT;
         dest_->dest_ = nullptr;
         dest_ = nullptr;
       }
     }
   }
 
   void SetWritable(bool writable) { set_writable(writable); }
 
-  void SetDestination(FakeTransportChannel* dest) {
+  // Simulates the two transport channels connecting to each other.
+  // If |asymmetric| is true this method only affects this FakeTransportChannel.
+  // If false, it affects |dest| as well.
+  void SetDestination(FakeTransportChannel* dest, bool asymmetric = false) {
     if (state_ == STATE_CONNECTING && dest) {
       // This simulates the delivery of candidates.
       dest_ = dest;
-      dest_->dest_ = this;
       if (local_cert_ && dest_->local_cert_) {
         do_dtls_ = true;
-        dest_->do_dtls_ = true;
         NegotiateSrtpCiphers();
       }
       state_ = STATE_CONNECTED;
-      dest_->state_ = STATE_CONNECTED;
       set_writable(true);
-      dest_->set_writable(true);
+      if (!asymmetric) {
+        dest->SetDestination(this, true);
+      }
     } else if (state_ == STATE_CONNECTED && !dest) {
       // Simulates loss of connectivity, by asymmetrically forgetting dest_.
       dest_ = nullptr;
       state_ = STATE_CONNECTING;
       set_writable(false);
     }
   }
 
   void SetConnectionCount(size_t connection_count) {
     size_t old_connection_count = connection_count_;
@@ skipping 107 matching lines @@
                             uint8_t* result,
                             size_t result_len) override {
     if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) {
       memset(result, 0xff, result_len);
       return true;
     }
 
     return false;
   }
 
-  void NegotiateSrtpCiphers() {
-    for (std::vector<int>::const_iterator it1 = srtp_ciphers_.begin();
-         it1 != srtp_ciphers_.end(); ++it1) {
-      for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin();
-           it2 != dest_->srtp_ciphers_.end(); ++it2) {
-        if (*it1 == *it2) {
-          chosen_crypto_suite_ = *it1;
-          dest_->chosen_crypto_suite_ = *it2;
-          return;
-        }
-      }
-    }
-  }
-
   bool GetStats(ConnectionInfos* infos) override {
     ConnectionInfo info;
     infos->clear();
     infos->push_back(info);
     return true;
   }
 
   void set_ssl_max_protocol_version(rtc::SSLProtocolVersion version) {
     ssl_max_version_ = version;
   }
   rtc::SSLProtocolVersion ssl_max_protocol_version() const {
     return ssl_max_version_;
   }
 
  private:
+  void NegotiateSrtpCiphers() {
+    for (std::vector<int>::const_iterator it1 = srtp_ciphers_.begin();
+         it1 != srtp_ciphers_.end(); ++it1) {
+      for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin();
+           it2 != dest_->srtp_ciphers_.end(); ++it2) {
+        if (*it1 == *it2) {
+          chosen_crypto_suite_ = *it1;
+          return;
+        }
+      }
+    }
+  }
+
   enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
   FakeTransportChannel* dest_ = nullptr;
   State state_ = STATE_INIT;
   bool async_ = false;
   Candidates remote_candidates_;
   rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
   rtc::FakeSSLCertificate* remote_cert_ = nullptr;
   bool do_dtls_ = false;
   std::vector<int> srtp_ciphers_;
   int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE;
@@ skipping 28 matching lines @@
   FakeTransport(const std::string& name, PortAllocator* allocator)
       : Transport(name, nullptr) {}
 
   ~FakeTransport() { DestroyAllChannels(); }
 
   const ChannelMap& channels() const { return channels_; }
 
   // If async, will send packets by "Post"-ing to message queue instead of
   // synchronously "Send"-ing.
   void SetAsync(bool async) { async_ = async; }
-  void SetDestination(FakeTransport* dest) {
+
+  // If |asymmetric| is true, only set the destination for this transport, and
+  // not |dest|.
+  void SetDestination(FakeTransport* dest, bool asymmetric = false) {
     dest_ = dest;
     for (const auto& kv : channels_) {
       kv.second->SetLocalCertificate(certificate_);
-      SetChannelDestination(kv.first, kv.second);
+      SetChannelDestination(kv.first, kv.second, asymmetric);
     }
   }
 
   void SetWritable(bool writable) {
     for (const auto& kv : channels_) {
       kv.second->SetWritable(writable);
     }
   }
 
   void SetLocalCertificate(
@@ skipping 31 matching lines @@
   using Transport::remote_description;
 
  protected:
   TransportChannelImpl* CreateTransportChannel(int component) override {
     if (channels_.find(component) != channels_.end()) {
       return nullptr;
     }
     FakeTransportChannel* channel = new FakeTransportChannel(name(), component);
     channel->set_ssl_max_protocol_version(ssl_max_version_);
     channel->SetAsync(async_);
-    SetChannelDestination(component, channel);
+    SetChannelDestination(component, channel, false);
     channels_[component] = channel;
     return channel;
   }
 
   void DestroyTransportChannel(TransportChannelImpl* channel) override {
     channels_.erase(channel->component());
     delete channel;
   }
 
  private:
   FakeTransportChannel* GetFakeChannel(int component) {
     auto it = channels_.find(component);
     return (it != channels_.end()) ? it->second : nullptr;
   }
 
-  void SetChannelDestination(int component, FakeTransportChannel* channel) {
+  void SetChannelDestination(int component,
+                             FakeTransportChannel* channel,
+                             bool asymmetric) {
     FakeTransportChannel* dest_channel = nullptr;
     if (dest_) {
       dest_channel = dest_->GetFakeChannel(component);
-      if (dest_channel) {
+      if (dest_channel && !asymmetric) {
         dest_channel->SetLocalCertificate(dest_->certificate_);
       }
     }
-    channel->SetDestination(dest_channel);
+    channel->SetDestination(dest_channel, asymmetric);
   }
 
   // Note, this is distinct from the Channel map owned by Transport.
   // This map just tracks the FakeTransportChannels created by this class.
   // It's mainly needed so that we can access a FakeTransportChannel directly,
   // even if wrapped by a DtlsTransportChannelWrapper.
   ChannelMap channels_;
   FakeTransport* dest_ = nullptr;
   bool async_ = false;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
@@ skipping 119 matching lines @@
     }
   }
 
  private:
   bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_