Reland: Remove global list of SRTP sessions.

webrtc/pc/srtpfilter.cc

 /*
  *  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.
  */
 
 #include "webrtc/pc/srtpfilter.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "webrtc/base/base64.h"
 #include "webrtc/base/byteorder.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/rtputils.h"
 
 // Enable this line to turn on SRTP debugging
 // #define SRTP_DEBUG
 
 #ifdef HAVE_SRTP
@@ skipping 161 matching lines @@
                << " recv cipher_suite " << recv_cs;
 
   return true;
 }
 
 bool SrtpFilter::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
     return false;
   }
-  ASSERT(send_session_ != NULL);
+  RTC_CHECK(send_session_);
   return send_session_->ProtectRtp(p, in_len, max_len, out_len);
 }
 
 bool SrtpFilter::ProtectRtp(void* p,
                             int in_len,
                             int max_len,
                             int* out_len,
                             int64_t* index) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to ProtectRtp: SRTP not active";
     return false;
   }
-  ASSERT(send_session_ != NULL);
+  RTC_CHECK(send_session_);
   return send_session_->ProtectRtp(p, in_len, max_len, out_len, index);
 }
 
 bool SrtpFilter::ProtectRtcp(void* p, int in_len, int max_len, int* out_len) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to ProtectRtcp: SRTP not active";
     return false;
   }
   if (send_rtcp_session_) {
     return send_rtcp_session_->ProtectRtcp(p, in_len, max_len, out_len);
   } else {
-    ASSERT(send_session_ != NULL);
+    RTC_CHECK(send_session_);
     return send_session_->ProtectRtcp(p, in_len, max_len, out_len);
   }
 }
 
 bool SrtpFilter::UnprotectRtp(void* p, int in_len, int* out_len) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to UnprotectRtp: SRTP not active";
     return false;
   }
-  ASSERT(recv_session_ != NULL);
+  RTC_CHECK(recv_session_);
   return recv_session_->UnprotectRtp(p, in_len, out_len);
 }
 
 bool SrtpFilter::UnprotectRtcp(void* p, int in_len, int* out_len) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to UnprotectRtcp: SRTP not active";
     return false;
   }
   if (recv_rtcp_session_) {
     return recv_rtcp_session_->UnprotectRtcp(p, in_len, out_len);
   } else {
-    ASSERT(recv_session_ != NULL);
+    RTC_CHECK(recv_session_);
     return recv_session_->UnprotectRtcp(p, in_len, out_len);
   }
 }
 
 bool SrtpFilter::GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len) {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to GetRtpAuthParams: SRTP not active";
     return false;
   }
 
-  ASSERT(send_session_ != NULL);
+  RTC_CHECK(send_session_);
   return send_session_->GetRtpAuthParams(key, key_len, tag_len);
 }
 
 void SrtpFilter::set_signal_silent_time(int signal_silent_time_in_ms) {
   signal_silent_time_in_ms_ = signal_silent_time_in_ms;
   if (IsActive()) {
-    ASSERT(send_session_ != NULL);
+    RTC_CHECK(send_session_);
     send_session_->set_signal_silent_time(signal_silent_time_in_ms);
-    ASSERT(recv_session_ != NULL);
+    RTC_CHECK(recv_session_);
     recv_session_->set_signal_silent_time(signal_silent_time_in_ms);
     if (send_rtcp_session_)
       send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
     if (recv_rtcp_session_)
       recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
   }
 }
 
 bool SrtpFilter::ExpectOffer(ContentSource source) {
   return ((state_ == ST_INIT) ||
@@ skipping 167 matching lines @@
   // example key_params: "inline:YUJDZGVmZ2hpSktMbW9QUXJzVHVWd3l6MTIzNDU2"
 
   // Fail if key-method is wrong.
   if (key_params.find("inline:") != 0) {
     return false;
   }
 
   // Fail if base64 decode fails, or the key is the wrong size.
   std::string key_b64(key_params.substr(7)), key_str;
   if (!rtc::Base64::Decode(key_b64, rtc::Base64::DO_STRICT,
-                                 &key_str, NULL) ||
+                           &key_str, nullptr) ||
       static_cast<int>(key_str.size()) != len) {
     return false;
   }
 
   memcpy(key, key_str.c_str(), len);
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // SrtpSession
 
 #ifdef HAVE_SRTP
 
 bool SrtpSession::inited_ = false;
 
-// This lock protects SrtpSession::inited_ and SrtpSession::sessions_.
+// This lock protects SrtpSession::inited_.
 rtc::GlobalLockPod SrtpSession::lock_;
 
 SrtpSession::SrtpSession()
-    : session_(NULL),
+    : session_(nullptr),
       rtp_auth_tag_len_(0),
       rtcp_auth_tag_len_(0),
       srtp_stat_(new SrtpStat()),
       last_send_seq_num_(-1) {
-  {
-    rtc::GlobalLockScope ls(&lock_);
-    sessions()->push_back(this);
-  }
   SignalSrtpError.repeat(srtp_stat_->SignalSrtpError);
 }
 
 SrtpSession::~SrtpSession() {
-  {
-    rtc::GlobalLockScope ls(&lock_);
-    sessions()->erase(std::find(sessions()->begin(), sessions()->end(), this));
-  }
   if (session_) {
+    srtp_set_user_data(session_, nullptr);
     srtp_dealloc(session_);
   }
 }
 
 bool SrtpSession::SetSend(int cs, const uint8_t* key, int len) {
   return SetKey(ssrc_any_outbound, cs, key, len);
 }
 
 bool SrtpSession::SetRecv(int cs, const uint8_t* key, int len) {
   return SetKey(ssrc_any_inbound, cs, key, len);
 }
 
 bool SrtpSession::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!session_) {
     LOG(LS_WARNING) << "Failed to protect SRTP packet: no SRTP Session";
     return false;
   }
 
   int need_len = in_len + rtp_auth_tag_len_;  // NOLINT
   if (max_len < need_len) {
     LOG(LS_WARNING) << "Failed to protect SRTP packet: The buffer length "
                     << max_len << " is less than the needed " << need_len;
     return false;
@@ skipping 22 matching lines @@
                              int max_len,
                              int* out_len,
                              int64_t* index) {
   if (!ProtectRtp(p, in_len, max_len, out_len)) {
     return false;
   }
   return (index) ? GetSendStreamPacketIndex(p, in_len, index) : true;
 }
 
 bool SrtpSession::ProtectRtcp(void* p, int in_len, int max_len, int* out_len) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!session_) {
     LOG(LS_WARNING) << "Failed to protect SRTCP packet: no SRTP Session";
     return false;
   }
 
   int need_len = in_len + sizeof(uint32_t) + rtcp_auth_tag_len_;  // NOLINT
   if (max_len < need_len) {
     LOG(LS_WARNING) << "Failed to protect SRTCP packet: The buffer length "
                     << max_len << " is less than the needed " << need_len;
     return false;
   }
 
   *out_len = in_len;
   int err = srtp_protect_rtcp(session_, p, out_len);
   srtp_stat_->AddProtectRtcpResult(err);
   if (err != err_status_ok) {
     LOG(LS_WARNING) << "Failed to protect SRTCP packet, err=" << err;
     return false;
   }
   return true;
 }
 
 bool SrtpSession::UnprotectRtp(void* p, int in_len, int* out_len) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!session_) {
     LOG(LS_WARNING) << "Failed to unprotect SRTP packet: no SRTP Session";
     return false;
   }
 
   *out_len = in_len;
   int err = srtp_unprotect(session_, p, out_len);
   uint32_t ssrc;
   if (GetRtpSsrc(p, in_len, &ssrc)) {
     srtp_stat_->AddUnprotectRtpResult(ssrc, err);
   }
   if (err != err_status_ok) {
     LOG(LS_WARNING) << "Failed to unprotect SRTP packet, err=" << err;
     return false;
   }
   return true;
 }
 
 bool SrtpSession::UnprotectRtcp(void* p, int in_len, int* out_len) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!session_) {
     LOG(LS_WARNING) << "Failed to unprotect SRTCP packet: no SRTP Session";
     return false;
   }
 
   *out_len = in_len;
   int err = srtp_unprotect_rtcp(session_, p, out_len);
   srtp_stat_->AddUnprotectRtcpResult(err);
   if (err != err_status_ok) {
     LOG(LS_WARNING) << "Failed to unprotect SRTCP packet, err=" << err;
     return false;
   }
   return true;
 }
 
 bool SrtpSession::GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len) {
 #if defined(ENABLE_EXTERNAL_AUTH)
-  ExternalHmacContext* external_hmac = NULL;
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  ExternalHmacContext* external_hmac = nullptr;
   // stream_template will be the reference context for other streams.
   // Let's use it for getting the keys.
   srtp_stream_ctx_t* srtp_context = session_->stream_template;
   if (srtp_context && srtp_context->rtp_auth) {
     external_hmac = reinterpret_cast<ExternalHmacContext*>(
         srtp_context->rtp_auth->state);
   }
 
   if (!external_hmac) {
     LOG(LS_ERROR) << "Failed to get auth keys from libsrtp!.";
     return false;
   }
 
   *key = external_hmac->key;
   *key_len = external_hmac->key_length;
   *tag_len = rtp_auth_tag_len_;
   return true;
 #else
   return false;
 #endif
 }
 
 bool SrtpSession::GetSendStreamPacketIndex(void* p,
                                            int in_len,
                                            int64_t* index) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   srtp_hdr_t* hdr = reinterpret_cast<srtp_hdr_t*>(p);
   srtp_stream_ctx_t* stream = srtp_get_stream(session_, hdr->ssrc);
-  if (stream == NULL)
+  if (!stream) {
     return false;
+  }
 
   // Shift packet index, put into network byte order
   *index = static_cast<int64_t>(
       rtc::NetworkToHost64(rdbx_get_packet_index(&stream->rtp_rdbx) << 16));
   return true;
 }
 
 void SrtpSession::set_signal_silent_time(int signal_silent_time_in_ms) {
   srtp_stat_->set_signal_silent_time(signal_silent_time_in_ms);
 }
 
 bool SrtpSession::SetKey(int type, int cs, const uint8_t* key, int len) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (session_) {
     LOG(LS_ERROR) << "Failed to create SRTP session: "
                   << "SRTP session already created";
     return false;
   }
 
   if (!Init()) {
     return false;
   }
 
@@ skipping 26 matching lines @@
   // If external authentication option is enabled, supply custom auth module
   // id EXTERNAL_HMAC_SHA1 in the policy structure.
   // We want to set this option only for rtp packets.
   // By default policy structure is initialized to HMAC_SHA1.
 #if defined(ENABLE_EXTERNAL_AUTH)
   // Enable external HMAC authentication only for outgoing streams.
   if (type == ssrc_any_outbound) {
     policy.rtp.auth_type = EXTERNAL_HMAC_SHA1;
   }
 #endif
-  policy.next = NULL;
+  policy.next = nullptr;
 
   int err = srtp_create(&session_, &policy);
   if (err != err_status_ok) {
-    session_ = NULL;
+    session_ = nullptr;
     LOG(LS_ERROR) << "Failed to create SRTP session, err=" << err;
     return false;
   }
 
-
+  srtp_set_user_data(session_, this);
   rtp_auth_tag_len_ = policy.rtp.auth_tag_len;
   rtcp_auth_tag_len_ = policy.rtcp.auth_tag_len;
   return true;
 }
 
 bool SrtpSession::Init() {
   rtc::GlobalLockScope ls(&lock_);
 
   if (!inited_) {
     int err;
@@ skipping 28 matching lines @@
     int err = srtp_shutdown();
     if (err) {
       LOG(LS_ERROR) << "srtp_shutdown failed. err=" << err;
       return;
     }
     inited_ = false;
   }
 }
 
 void SrtpSession::HandleEvent(const srtp_event_data_t* ev) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   switch (ev->event) {
     case event_ssrc_collision:
       LOG(LS_INFO) << "SRTP event: SSRC collision";
       break;
     case event_key_soft_limit:
       LOG(LS_INFO) << "SRTP event: reached soft key usage limit";
       break;
     case event_key_hard_limit:
       LOG(LS_INFO) << "SRTP event: reached hard key usage limit";
       break;
     case event_packet_index_limit:
       LOG(LS_INFO) << "SRTP event: reached hard packet limit (2^48 packets)";
       break;
     default:
       LOG(LS_INFO) << "SRTP event: unknown " << ev->event;
       break;
   }
 }
 
 void SrtpSession::HandleEventThunk(srtp_event_data_t* ev) {
-  rtc::GlobalLockScope ls(&lock_);
-
-  for (std::list<SrtpSession*>::iterator it = sessions()->begin();
-       it != sessions()->end(); ++it) {
-    if ((*it)->session_ == ev->session) {
-      (*it)->HandleEvent(ev);
-      break;
-    }
+  // Callback will be executed from same thread that calls the "srtp_protect"
+  // and "srtp_unprotect" functions.
+  SrtpSession* session = static_cast<SrtpSession*>(
+      srtp_get_user_data(ev->session));
+  if (session) {
+    session->HandleEvent(ev);
   }
 }
 
-std::list<SrtpSession*>* SrtpSession::sessions() {
-  RTC_DEFINE_STATIC_LOCAL(std::list<SrtpSession*>, sessions, ());
-  return &sessions;
-}
-
 #else   // !HAVE_SRTP
 
 // On some systems, SRTP is not (yet) available.
 
 SrtpSession::SrtpSession() {
   LOG(WARNING) << "SRTP implementation is missing.";
 }
 
 SrtpSession::~SrtpSession() {
 }
@@ skipping 127 matching lines @@
   SrtpNotAvailable(__FUNCTION__);
 }
 
 void SrtpStat::HandleSrtpResult(const SrtpStat::FailureKey& key) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 #endif  // HAVE_SRTP
 
 }  // namespace cricket