Delete SignalSrtpError.

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.
  */
 
@@ skipping 95 matching lines @@
                                const uint8_t* recv_key,
                                int recv_key_len) {
   // This can only be called once, but can be safely called after
   // SetRtpParams
   if (send_rtcp_session_ || recv_rtcp_session_) {
     LOG(LS_ERROR) << "Tried to set SRTCP Params when filter already active";
     return false;
   }
 
   send_rtcp_session_.reset(new SrtpSession());
-  SignalSrtpError.repeat(send_rtcp_session_->SignalSrtpError);
-  send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
   if (!send_rtcp_session_->SetRecv(send_cs, send_key, send_key_len))
     return false;
 
   recv_rtcp_session_.reset(new SrtpSession());
-  SignalSrtpError.repeat(recv_rtcp_session_->SignalSrtpError);
-  recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
   if (!recv_rtcp_session_->SetRecv(recv_cs, recv_key, recv_key_len))
     return false;
 
   LOG(LS_INFO) << "SRTCP activated with negotiated parameters:"
                << " send cipher_suite " << send_cs
                << " recv cipher_suite " << recv_cs;
 
   return true;
 }
 
@@ skipping 87 matching lines @@
 bool SrtpFilter::IsExternalAuthActive() const {
   if (!IsActive()) {
     LOG(LS_WARNING) << "Failed to check IsExternalAuthActive: SRTP not active";
     return false;
   }
 
   RTC_CHECK(send_session_);
   return send_session_->IsExternalAuthActive();
 }
 
-void SrtpFilter::set_signal_silent_time(int signal_silent_time_in_ms) {
-  signal_silent_time_in_ms_ = signal_silent_time_in_ms;
-  if (IsActive()) {
-    RTC_CHECK(send_session_);
-    send_session_->set_signal_silent_time(signal_silent_time_in_ms);
-    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) ||
           (state_ == ST_ACTIVE) ||
           (state_  == ST_SENTOFFER && source == CS_LOCAL) ||
           (state_  == ST_SENTUPDATEDOFFER && source == CS_LOCAL) ||
           (state_ == ST_RECEIVEDOFFER && source == CS_REMOTE) ||
           (state_ == ST_RECEIVEDUPDATEDOFFER && source == CS_REMOTE));
 }
 
 bool SrtpFilter::StoreParams(const std::vector<CryptoParams>& params,
@@ skipping 61 matching lines @@
   }
   return true;
 }
 
 void SrtpFilter::CreateSrtpSessions() {
   send_session_.reset(new SrtpSession());
   applied_send_params_ = CryptoParams();
   recv_session_.reset(new SrtpSession());
   applied_recv_params_ = CryptoParams();
 
-  SignalSrtpError.repeat(send_session_->SignalSrtpError);
-  SignalSrtpError.repeat(recv_session_->SignalSrtpError);
-
-  send_session_->set_signal_silent_time(signal_silent_time_in_ms_);
-  recv_session_->set_signal_silent_time(signal_silent_time_in_ms_);
   if (external_auth_enabled_) {
     send_session_->EnableExternalAuth();
   }
 }
 
 bool SrtpFilter::NegotiateParams(const std::vector<CryptoParams>& answer_params,
                                  CryptoParams* selected_params) {
   // We're processing an accept. We should have exactly one set of params,
   // unless the offer didn't mention crypto, in which case we shouldn't be here.
   bool ret = (answer_params.size() == 1U && !offer_params_.empty());
@@ skipping 118 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // SrtpSession
 
 bool SrtpSession::inited_ = false;
 
 // This lock protects SrtpSession::inited_.
 rtc::GlobalLockPod SrtpSession::lock_;
 
-SrtpSession::SrtpSession() : srtp_stat_(new SrtpStat()) {
-  SignalSrtpError.repeat(srtp_stat_->SignalSrtpError);
-}
+SrtpSession::SrtpSession() {}
 
 SrtpSession::~SrtpSession() {
   if (session_) {
     srtp_set_user_data(session_, nullptr);
     srtp_dealloc(session_);
   }
 }
 
 bool SrtpSession::SetSend(int cs, const uint8_t* key, size_t len) {
   return SetKey(ssrc_any_outbound, cs, key, len);
@@ skipping 12 matching lines @@
 
   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;
   }
 
   *out_len = in_len;
   int err = srtp_protect(session_, p, out_len);
-  uint32_t ssrc;
-  if (GetRtpSsrc(p, in_len, &ssrc)) {
-    srtp_stat_->AddProtectRtpResult(ssrc, err);
-  }
   int seq_num;
   GetRtpSeqNum(p, in_len, &seq_num);
   if (err != srtp_err_status_ok) {
     LOG(LS_WARNING) << "Failed to protect SRTP packet, seqnum="
                     << seq_num << ", err=" << err << ", last seqnum="
                     << last_send_seq_num_;
     return false;
   }
   last_send_seq_num_ = seq_num;
   return true;
@@ skipping 19 matching lines @@
 
   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 != srtp_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 != srtp_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 != srtp_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) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(IsExternalAuthActive());
@@ skipping 48 matching lines @@
     return false;
   }
 
   // Shift packet index, put into network byte order
   *index = static_cast<int64_t>(
       rtc::NetworkToHost64(
           srtp_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, size_t 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 133 matching lines @@
 void SrtpSession::HandleEventThunk(srtp_event_data_t* ev) {
   // 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);
   }
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// SrtpStat
-
-SrtpStat::SrtpStat()
-    : signal_silent_time_(1000) {
-}
-
-void SrtpStat::AddProtectRtpResult(uint32_t ssrc, int result) {
-  FailureKey key;
-  key.ssrc = ssrc;
-  key.mode = SrtpFilter::PROTECT;
-  switch (result) {
-    case srtp_err_status_ok:
-      key.error = SrtpFilter::ERROR_NONE;
-      break;
-    case srtp_err_status_auth_fail:
-      key.error = SrtpFilter::ERROR_AUTH;
-      break;
-    default:
-      key.error = SrtpFilter::ERROR_FAIL;
-  }
-  HandleSrtpResult(key);
-}
-
-void SrtpStat::AddUnprotectRtpResult(uint32_t ssrc, int result) {
-  FailureKey key;
-  key.ssrc = ssrc;
-  key.mode = SrtpFilter::UNPROTECT;
-  switch (result) {
-    case srtp_err_status_ok:
-      key.error = SrtpFilter::ERROR_NONE;
-      break;
-    case srtp_err_status_auth_fail:
-      key.error = SrtpFilter::ERROR_AUTH;
-      break;
-    case srtp_err_status_replay_fail:
-    case srtp_err_status_replay_old:
-      key.error = SrtpFilter::ERROR_REPLAY;
-      break;
-    default:
-      key.error = SrtpFilter::ERROR_FAIL;
-  }
-  HandleSrtpResult(key);
-}
-
-void SrtpStat::AddProtectRtcpResult(int result) {
-  AddProtectRtpResult(0U, result);
-}
-
-void SrtpStat::AddUnprotectRtcpResult(int result) {
-  AddUnprotectRtpResult(0U, result);
-}
-
-void SrtpStat::HandleSrtpResult(const SrtpStat::FailureKey& key) {
-  // Handle some cases where error should be signalled right away. For other
-  // errors, trigger error for the first time seeing it.  After that, silent
-  // the same error for a certain amount of time (default 1 sec).
-  if (key.error != SrtpFilter::ERROR_NONE) {
-    // For errors, signal first time and wait for 1 sec.
-    FailureStat* stat = &(failures_[key]);
-    int64_t current_time = rtc::TimeMillis();
-    if (stat->last_signal_time == 0 ||
-        rtc::TimeDiff(current_time, stat->last_signal_time) >
-            signal_silent_time_) {
-      SignalSrtpError(key.ssrc, key.mode, key.error);
-      stat->last_signal_time = current_time;
-    }
-  }
-}
-
 }  // namespace cricket