Completed the functionalities of SrtpTransport.

webrtc/pc/srtptransport.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_PC_SRTPTRANSPORT_H_
 #define WEBRTC_PC_SRTPTRANSPORT_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "webrtc/pc/rtptransportinternal.h"
 #include "webrtc/pc/srtpfilter.h"
+#include "webrtc/pc/srtpsession.h"
 #include "webrtc/rtc_base/checks.h"
 
 namespace webrtc {
 
 // This class will eventually be a wrapper around RtpTransportInternal
 // that protects and unprotects sent and received RTP packets. This
 // functionality is currently implemented by SrtpFilter and BaseChannel, but
 // will be moved here in the future.
 class SrtpTransport : public RtpTransportInternal {
  public:
   SrtpTransport(bool rtcp_mux_enabled, const std::string& content_name);
 
   // TODO(zstein): Consider taking an RtpTransport instead of an
   // RtpTransportInternal.
   SrtpTransport(std::unique_ptr<RtpTransportInternal> transport,

[Taylor Brandstetter, 2017/08/23 22:13:30]

If we remove support for upgrading from plain RTP to SRTP, then I think we can
remove the RtpTransportInternal argument from the constructor. The fact that
SrtpTransport wraps an RtpTransport internally can be an implementation detail,
and it can construct the inner RtpTransport itself.

[Zhi Huang, 2017/08/24 23:38:07]

Acknowledged.

                 const std::string& content_name);
 
   void SetRtcpMuxEnabled(bool enable) override {
     rtp_transport_->SetRtcpMuxEnabled(enable);
   }
 
   rtc::PacketTransportInternal* rtp_packet_transport() const override {
     return rtp_transport_->rtp_packet_transport();
   }
 
@@ skipping 13 matching lines @@
   }
 
   PacketTransportInterface* GetRtcpPacketTransport() const override {
     return rtp_transport_->GetRtcpPacketTransport();
   }
 
   bool IsWritable(bool rtcp) const override {
     return rtp_transport_->IsWritable(rtcp);
   }
 
+  bool IsActive() const;

[Taylor Brandstetter, 2017/08/23 22:13:30]

Some comments for this method and the other new methods would be helpful.

[Zhi Huang, 2017/08/24 23:38:07]

Done.

+
   bool SendPacket(bool rtcp,
                   rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options,
                   int flags) override;
 
   bool HandlesPayloadType(int payload_type) const override {
     return rtp_transport_->HandlesPayloadType(payload_type);
   }
 
   void AddHandledPayloadType(int payload_type) override {
     rtp_transport_->AddHandledPayloadType(payload_type);
   }
 
   RtcpParameters GetRtcpParameters() const override {
     return rtp_transport_->GetRtcpParameters();
   }
 
   RTCError SetRtcpParameters(const RtcpParameters& parameters) override {
     return rtp_transport_->SetRtcpParameters(parameters);
   }
 
   // TODO(zstein): Remove this when we remove RtpTransportAdapter.
   RtpTransportAdapter* GetInternal() override { return nullptr; }
 
+  bool SetRtpParams(int send_cs,
+                    const uint8_t* send_key,
+                    int send_key_len,
+                    int recv_cs,
+                    const uint8_t* recv_key,
+                    int recv_key_len);
+
+  bool SetRtcpParams(int send_cs,
+                     const uint8_t* send_key,
+                     int send_key_len,
+                     int recv_cs,
+                     const uint8_t* recv_key,
+                     int recv_key_len);
+
+  bool UpdateRtpParams(int send_cs,
+                       const uint8_t* send_key,
+                       int send_key_len,
+                       int recv_cs,
+                       const uint8_t* recv_key,
+                       int recv_key_len);
+
+  void ResetParams();
+
+  void SetEncryptedHeaderExtensionIds(cricket::ContentSource source,
+                                      const std::vector<int>& extension_ids);
+
+  // If external auth is enabled, SRTP will write a dummy auth tag that then
+  // later must get replaced before the packet is sent out. Only supported for
+  // non-GCM cipher suites and can be checked through "IsExternalAuthActive"
+  // if it is actually used. This method is only valid before the RTP params
+  // have been set.
+  void EnableExternalAuth();
+  bool IsExternalAuthEnabled() const;
+
+  // A SrtpTransport supports external creation of the auth tag if a non-GCM
+  // cipher is used. This method is only valid after the RTP params have
+  // been set.
+  bool IsExternalAuthActive() const;
+
+  // Returns srtp overhead for rtp packets.
+  bool GetSrtpOverhead(int* srtp_overhead) const;
+
+  void CacheRtpAbsSendTimeHeaderExtension(int rtp_abs_sendtime_extn_id) {
+    rtp_abs_sendtime_extn_id_ = rtp_abs_sendtime_extn_id;
+  }
+
  private:
+  void CreateSrtpSessions();
+
   void ConnectToRtpTransport();
 
   void OnPacketReceived(bool rtcp,
                         rtc::CopyOnWriteBuffer* packet,
                         const rtc::PacketTime& packet_time);
 
   void OnReadyToSend(bool ready) { SignalReadyToSend(ready); }
 
+  bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
+
+  // Overloaded version, outputs packet index.
+  bool ProtectRtp(void* data,
+                  int in_len,
+                  int max_len,
+                  int* out_len,
+                  int64_t* index);
+  bool ProtectRtcp(void* data, int in_len, int max_len, int* out_len);
+
+  // Decrypts/verifies an invidiual RTP/RTCP packet.
+  // If an HMAC is used, this will decrease the packet size.
+  bool UnprotectRtp(void* data, int in_len, int* out_len);
+
+  bool UnprotectRtcp(void* data, int in_len, int* out_len);
+
+  // Returns rtp auth params from srtp context.
+  bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
+
   const std::string content_name_;
+  std::unique_ptr<RtpTransportInternal> rtp_transport_;
 
-  std::unique_ptr<RtpTransportInternal> rtp_transport_;
+  std::unique_ptr<cricket::SrtpSession> send_session_;
+  std::unique_ptr<cricket::SrtpSession> recv_session_;
+  std::unique_ptr<cricket::SrtpSession> send_rtcp_session_;
+  std::unique_ptr<cricket::SrtpSession> recv_rtcp_session_;
+
+  std::vector<int> send_encrypted_header_extension_ids_;
+  std::vector<int> recv_encrypted_header_extension_ids_;
+  bool external_auth_enabled_ = false;
+
+  int rtp_abs_sendtime_extn_id_ = -1;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_PC_SRTPTRANSPORT_H_