Create the SrtpTransportInterface.

webrtc/ortc/rtptransportcontrolleradapter.cc

 /*
  *  Copyright 2017 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.
  */
 
 #include "webrtc/ortc/rtptransportcontrolleradapter.h"
 
 #include <algorithm>  // For "remove", "find".
+#include <set>
 #include <sstream>
-#include <set>
 #include <unordered_map>
 #include <utility>  // For std::move.
 
 #include "webrtc/api/proxy.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/ortc/ortcrtpreceiveradapter.h"
 #include "webrtc/ortc/ortcrtpsenderadapter.h"
 #include "webrtc/ortc/rtpparametersconversion.h"
 #include "webrtc/ortc/rtptransportadapter.h"
@@ skipping 105 matching lines @@
   auto result =
       RtpTransportAdapter::CreateProxied(rtcp_parameters, rtp, rtcp, this);
   if (result.ok()) {
     transport_proxies_.push_back(result.value().get());
     transport_proxies_.back()->GetInternal()->SignalDestroyed.connect(
         this, &RtpTransportControllerAdapter::OnRtpTransportDestroyed);
   }
   return result;
 }
 
+RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>
+RtpTransportControllerAdapter::CreateProxiedSrtpTransport(
+    const RtcpParameters& rtcp_parameters,
+    PacketTransportInterface* rtp,
+    PacketTransportInterface* rtcp) {
+  auto result =
+      RtpTransportAdapter::CreateSrtpProxied(rtcp_parameters, rtp, rtcp, this);
+  if (result.ok()) {
+    transport_proxies_.push_back(result.value().get());
+    transport_proxies_.back()->GetInternal()->SignalDestroyed.connect(
+        this, &RtpTransportControllerAdapter::OnRtpTransportDestroyed);
+  }
+  return result;
+}
+
 RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>>
 RtpTransportControllerAdapter::CreateProxiedRtpSender(
     cricket::MediaType kind,
     RtpTransportInterface* transport_proxy) {
   RTC_DCHECK(transport_proxy);
   RTC_DCHECK(std::find(transport_proxies_.begin(), transport_proxies_.end(),
                        transport_proxy) != transport_proxies_.end());
   std::unique_ptr<OrtcRtpSenderAdapter> new_sender(
       new OrtcRtpSenderAdapter(kind, transport_proxy, this));
   RTCError err;
@@ skipping 447 matching lines @@
                          "Using two audio RtpSenders with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
   }
   if (inner_audio_transport_ && inner_audio_transport_ != inner_transport) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using different transports for the audio "
                          "RtpSender and RtpReceiver is not currently "
                          "supported.");
   }
+  RTCError err = MaybeSetCryptos(inner_transport, &local_audio_description_,
+                                 &remote_audio_description_);
+  if (!err.ok()) {
+    return err;
+  }
   // If setting new transport, extract its RTCP parameters and create voice
   // channel.
   if (!inner_audio_transport_) {
     CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
                                      &local_audio_description_,
                                      &remote_audio_description_);
     inner_audio_transport_ = inner_transport;
     CreateVoiceChannel();
   }
   have_audio_sender_ = true;
@@ skipping 10 matching lines @@
                          "Using two video RtpSenders with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
   }
   if (inner_video_transport_ && inner_video_transport_ != inner_transport) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using different transports for the video "
                          "RtpSender and RtpReceiver is not currently "
                          "supported.");
   }
+  RTCError err = MaybeSetCryptos(inner_transport, &local_video_description_,
+                                 &remote_video_description_);
+  if (!err.ok()) {
+    return err;
+  }
   // If setting new transport, extract its RTCP parameters and create video
   // channel.
   if (!inner_video_transport_) {
     CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
                                      &local_video_description_,
                                      &remote_video_description_);
     inner_video_transport_ = inner_transport;
     CreateVideoChannel();
   }
   have_video_sender_ = true;
@@ skipping 10 matching lines @@
                          "Using two audio RtpReceivers with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
   }
   if (inner_audio_transport_ && inner_audio_transport_ != inner_transport) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using different transports for the audio "
                          "RtpReceiver and RtpReceiver is not currently "
                          "supported.");
   }
+  RTCError err = MaybeSetCryptos(inner_transport, &local_audio_description_,
+                                 &remote_audio_description_);
+  if (!err.ok()) {
+    return err;
+  }
   // If setting new transport, extract its RTCP parameters and create voice
   // channel.
   if (!inner_audio_transport_) {
     CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
                                      &local_audio_description_,
                                      &remote_audio_description_);
     inner_audio_transport_ = inner_transport;
     CreateVoiceChannel();
   }
   have_audio_receiver_ = true;
@@ skipping 10 matching lines @@
                          "Using two video RtpReceivers with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
   }
   if (inner_video_transport_ && inner_video_transport_ != inner_transport) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using different transports for the video "
                          "RtpReceiver and RtpReceiver is not currently "
                          "supported.");
   }
+  RTCError err = MaybeSetCryptos(inner_transport, &local_video_description_,
+                                 &remote_video_description_);
+  if (!err.ok()) {
+    return err;
+  }
   // If setting new transport, extract its RTCP parameters and create video
   // channel.
   if (!inner_video_transport_) {
     CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
                                      &local_video_description_,
                                      &remote_video_description_);
     inner_video_transport_ = inner_transport;
     CreateVideoChannel();
   }
   have_video_receiver_ = true;
@@ skipping 181 matching lines @@
   auto result = ToCricketStreamParamsVec(encodings);
   if (!result.ok()) {
     return result.MoveError();
   }
   // If conversion was successful, there should be one StreamParams.
   RTC_DCHECK_EQ(1u, result.value().size());
   result.value()[0].cname = cname;
   return result;
 }
 
+RTCError RtpTransportControllerAdapter::MaybeSetCryptos(
+    RtpTransportInterface* rtp_transport,
+    cricket::MediaContentDescription* local_description,
+    cricket::MediaContentDescription* remote_description) {
+  if (rtp_transport->GetInternal()->is_srtp_transport()) {
+    if (!rtp_transport->GetInternal()->send_key() ||
+        !rtp_transport->GetInternal()->receive_key()) {
+      LOG_AND_RETURN_ERROR(webrtc::RTCErrorType::UNSUPPORTED_PARAMETER,
+                           "The SRTP send key or receive key is not set.")
+    }
+    std::vector<cricket::CryptoParams> cryptos;
+    cryptos.push_back(*(rtp_transport->GetInternal()->receive_key()));
+    local_description->set_cryptos(cryptos);
+
+    cryptos.clear();
+    cryptos.push_back(*(rtp_transport->GetInternal()->send_key()));
+    remote_description->set_cryptos(cryptos);
+  }
+  return RTCError::OK();
+}
+
 }  // namespace webrtc