Negotiate the same SRTP crypto suites for every DTLS association formed.

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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 224 matching lines @@
 
 bool BaseChannel::InitNetwork_n(
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
     rtc::PacketTransportInternal* rtp_packet_transport,
     rtc::PacketTransportInternal* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport,
                   rtcp_packet_transport);
 
-  if (rtp_dtls_transport_ &&
-      !SetDtlsSrtpCryptoSuites_n(rtp_dtls_transport_, false)) {
-    return false;
-  }
-  if (rtcp_dtls_transport_ &&
-      !SetDtlsSrtpCryptoSuites_n(rtcp_dtls_transport_, true)) {
-    return false;
-  }
   if (rtp_transport_.rtcp_mux_required()) {
     rtcp_mux_filter_.SetActive();
   }
   return true;
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(NULL);
   // Packets arrive on the network thread, processing packets calls virtual
@@ skipping 320 matching lines @@
       break;
     case ST_RTCP:
       transport = rtp_transport_.rtcp_packet_transport();
       rtcp_socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
   }
   return transport ? transport->SetOption(opt, value) : -1;
 }
 
-bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
-  crypto_options_ = crypto_options;
-  return true;
-}
-
 void BaseChannel::OnWritableState(rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(transport == rtp_transport_.rtp_packet_transport() ||
              transport == rtp_transport_.rtcp_packet_transport());
   RTC_DCHECK(network_thread_->IsCurrent());
   UpdateWritableState_n();
 }
 
 void BaseChannel::OnPacketRead(rtc::PacketTransportInternal* transport,
                                const char* data,
                                size_t len,
@@ skipping 406 matching lines @@
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, signaling_thread(),
       Bind(&BaseChannel::SignalDtlsSrtpSetupFailure_s, this, rtcp));
 }
 
 void BaseChannel::SignalDtlsSrtpSetupFailure_s(bool rtcp) {
   RTC_DCHECK(signaling_thread() == rtc::Thread::Current());
   SignalDtlsSrtpSetupFailure(this, rtcp);
 }
 
-bool BaseChannel::SetDtlsSrtpCryptoSuites_n(DtlsTransportInternal* transport,
-                                            bool rtcp) {
-  std::vector<int> crypto_suites;
-  // We always use the default SRTP crypto suites for RTCP, but we may use
-  // different crypto suites for RTP depending on the media type.
-  if (!rtcp) {
-    GetSrtpCryptoSuites_n(&crypto_suites);
-  } else {
-    GetDefaultSrtpCryptoSuites(crypto_options(), &crypto_suites);
-  }
-  return transport->SetSrtpCryptoSuites(crypto_suites);
-}
-
 bool BaseChannel::ShouldSetupDtlsSrtp_n() const {
   // Since DTLS is applied to all transports, checking RTP should be enough.
   return rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
 }
 
 // This function returns true if either DTLS-SRTP is not in use
 // *or* DTLS-SRTP is successfully set up.
 bool BaseChannel::SetupDtlsSrtp_n(bool rtcp) {
   RTC_DCHECK(network_thread_->IsCurrent());
   bool ret = false;
@@ skipping 902 matching lines @@
     VoiceMediaChannel* media_channel, const VoiceMediaInfo& info) {
   RTC_DCHECK(media_channel == this->media_channel());
   SignalMediaMonitor(this, info);
 }
 
 void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor,
                                         const AudioInfo& info) {
   SignalAudioMonitor(this, info);
 }
 
-void VoiceChannel::GetSrtpCryptoSuites_n(
-    std::vector<int>* crypto_suites) const {
-  GetSupportedAudioCryptoSuites(crypto_options(), crypto_suites);
-}
-
 VideoChannel::VideoChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
                            rtc::Thread* signaling_thread,
                            VideoMediaChannel* media_channel,
                            const std::string& content_name,
                            bool rtcp_mux_required,
                            bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
@@ skipping 231 matching lines @@
 }
 
 // TODO(pthatcher): Look into removing duplicate code between
 // audio, video, and data, perhaps by using templates.
 void VideoChannel::OnMediaMonitorUpdate(
     VideoMediaChannel* media_channel, const VideoMediaInfo &info) {
   RTC_DCHECK(media_channel == this->media_channel());
   SignalMediaMonitor(this, info);
 }
 
-void VideoChannel::GetSrtpCryptoSuites_n(
-    std::vector<int>* crypto_suites) const {
-  GetSupportedVideoCryptoSuites(crypto_options(), crypto_suites);
-}
-
 RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
                                rtc::Thread* network_thread,
                                rtc::Thread* signaling_thread,
                                DataMediaChannel* media_channel,
                                const std::string& content_name,
                                bool rtcp_mux_required,
                                bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
@@ skipping 250 matching lines @@
 }
 
 void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
   // This is usded for congestion control to indicate that the stream is ready
   // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
   // that the transport channel is ready.
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
-void RtpDataChannel::GetSrtpCryptoSuites_n(
-    std::vector<int>* crypto_suites) const {
-  GetSupportedDataCryptoSuites(crypto_options(), crypto_suites);
-}
-
 }  // namespace cricket