Use suffixed {uint,int}{8,16,32,64}_t types.

talk/session/media/srtpfilter.cc

 /*
  * libjingle
  * Copyright 2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 129 matching lines @@
   return DoSetAnswer(answer_params, source, true);
 }
 
 bool SrtpFilter::SetProvisionalAnswer(
     const std::vector<CryptoParams>& answer_params,
     ContentSource source) {
   return DoSetAnswer(answer_params, source, false);
 }
 
 bool SrtpFilter::SetRtpParams(const std::string& send_cs,
-                              const uint8* send_key, int send_key_len,
+                              const uint8_t* send_key,
+                              int send_key_len,
                               const std::string& recv_cs,
-                              const uint8* recv_key, int recv_key_len) {
+                              const uint8_t* recv_key,
+                              int recv_key_len) {
   if (IsActive()) {
     LOG(LS_ERROR) << "Tried to set SRTP Params when filter already active";
     return false;
   }
   CreateSrtpSessions();
   if (!send_session_->SetSend(send_cs, send_key, send_key_len))
     return false;
 
   if (!recv_session_->SetRecv(recv_cs, recv_key, recv_key_len))
     return false;
 
   state_ = ST_ACTIVE;
 
   LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
                << " send cipher_suite " << send_cs
                << " recv cipher_suite " << recv_cs;
   return true;
 }
 
 // This function is provided separately because DTLS-SRTP behaves
 // differently in RTP/RTCP mux and non-mux modes.
 //
 // - In the non-muxed case, RTP and RTCP are keyed with different
 //   keys (from different DTLS handshakes), and so we need a new
 //   SrtpSession.
 // - In the muxed case, they are keyed with the same keys, so
 //   this function is not needed
 bool SrtpFilter::SetRtcpParams(const std::string& send_cs,
-                               const uint8* send_key, int send_key_len,
+                               const uint8_t* send_key,
+                               int send_key_len,
                                const std::string& recv_cs,
-                               const uint8* recv_key, int recv_key_len) {
+                               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_);
@@ skipping 15 matching lines @@
 
 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);
   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* index) {
+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);
   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()) {
@@ skipping 23 matching lines @@
     return false;
   }
   if (recv_rtcp_session_) {
     return recv_rtcp_session_->UnprotectRtcp(p, in_len, out_len);
   } else {
     ASSERT(recv_session_ != NULL);
     return recv_session_->UnprotectRtcp(p, in_len, out_len);
   }
 }
 
-bool SrtpFilter::GetRtpAuthParams(uint8** key, int* key_len, int* tag_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);
   return send_session_->GetRtpAuthParams(key, key_len, tag_len);
 }
 
-void SrtpFilter::set_signal_silent_time(uint32 signal_silent_time_in_ms) {
+void SrtpFilter::set_signal_silent_time(uint32_t signal_silent_time_in_ms) {
   signal_silent_time_in_ms_ = signal_silent_time_in_ms;
   if (IsActive()) {
     ASSERT(send_session_ != NULL);
     send_session_->set_signal_silent_time(signal_silent_time_in_ms);
     ASSERT(recv_session_ != NULL);
     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);
@@ skipping 124 matching lines @@
       applied_send_params_.key_params == send_params.key_params &&
       applied_recv_params_.cipher_suite == recv_params.cipher_suite &&
       applied_recv_params_.key_params == recv_params.key_params) {
     LOG(LS_INFO) << "Applying the same SRTP parameters again. No-op.";
 
     // We do not want to reset the ROC if the keys are the same. So just return.
     return true;
   }
   // TODO(juberti): Zero these buffers after use.
   bool ret;
-  uint8 send_key[SRTP_MASTER_KEY_LEN], recv_key[SRTP_MASTER_KEY_LEN];
+  uint8_t send_key[SRTP_MASTER_KEY_LEN], recv_key[SRTP_MASTER_KEY_LEN];
   ret = (ParseKeyParams(send_params.key_params, send_key, sizeof(send_key)) &&
          ParseKeyParams(recv_params.key_params, recv_key, sizeof(recv_key)));
   if (ret) {
     CreateSrtpSessions();
     ret = (send_session_->SetSend(send_params.cipher_suite,
                                   send_key, sizeof(send_key)) &&
            recv_session_->SetRecv(recv_params.cipher_suite,
                                   recv_key, sizeof(recv_key)));
   }
   if (ret) {
     LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
                  << " send cipher_suite " << send_params.cipher_suite
                  << " recv cipher_suite " << recv_params.cipher_suite;
     applied_send_params_ = send_params;
     applied_recv_params_ = recv_params;
   } else {
     LOG(LS_WARNING) << "Failed to apply negotiated SRTP parameters";
   }
   return ret;
 }
 
 bool SrtpFilter::ResetParams() {
   offer_params_.clear();
   state_ = ST_INIT;
   LOG(LS_INFO) << "SRTP reset to init state";
   return true;
 }
 
 bool SrtpFilter::ParseKeyParams(const std::string& key_params,
-                                uint8* key, int len) {
+                                uint8_t* key,
+                                int len) {
   // 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,
@@ skipping 32 matching lines @@
 SrtpSession::~SrtpSession() {
   {
     rtc::GlobalLockScope ls(&lock_);
     sessions()->erase(std::find(sessions()->begin(), sessions()->end(), this));
   }
   if (session_) {
     srtp_dealloc(session_);
   }
 }
 
-bool SrtpSession::SetSend(const std::string& cs, const uint8* key, int len) {
+bool SrtpSession::SetSend(const std::string& cs, const uint8_t* key, int len) {
   return SetKey(ssrc_any_outbound, cs, key, len);
 }
 
-bool SrtpSession::SetRecv(const std::string& cs, const uint8* key, int len) {
+bool SrtpSession::SetRecv(const std::string& 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) {
   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;
   }
 
   *out_len = in_len;
   int err = srtp_protect(session_, p, out_len);
-  uint32 ssrc;
+  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 != 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;
 }
 
-bool SrtpSession::ProtectRtp(void* p, int in_len, int max_len, int* out_len,
-                             int64* index) {
+bool SrtpSession::ProtectRtp(void* p,
+                             int in_len,
+                             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) {
   if (!session_) {
     LOG(LS_WARNING) << "Failed to protect SRTCP packet: no SRTP Session";
     return false;
   }
 
-  int need_len = in_len + sizeof(uint32) + rtcp_auth_tag_len_;  // NOLINT
+  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) {
   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 ssrc;
+  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) {
   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** key, int* key_len,
-                                   int* tag_len) {
+bool SrtpSession::GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len) {
 #if defined(ENABLE_EXTERNAL_AUTH)
   ExternalHmacContext* external_hmac = NULL;
   // 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* index) {
+bool SrtpSession::GetSendStreamPacketIndex(void* p,
+                                           int in_len,
+                                           int64_t* index) {
   srtp_hdr_t* hdr = reinterpret_cast<srtp_hdr_t*>(p);
   srtp_stream_ctx_t* stream = srtp_get_stream(session_, hdr->ssrc);
   if (stream == NULL)
     return false;
 
   // Shift packet index, put into network byte order
-  *index = static_cast<int64>(
+  *index = static_cast<int64_t>(
       rtc::NetworkToHost64(rdbx_get_packet_index(&stream->rtp_rdbx) << 16));
   return true;
 }
 
-void SrtpSession::set_signal_silent_time(uint32 signal_silent_time_in_ms) {
+void SrtpSession::set_signal_silent_time(uint32_t signal_silent_time_in_ms) {
   srtp_stat_->set_signal_silent_time(signal_silent_time_in_ms);
 }
 
-bool SrtpSession::SetKey(int type, const std::string& cs,
-                         const uint8* key, int len) {
+bool SrtpSession::SetKey(int type,
+                         const std::string& cs,
+                         const uint8_t* key,
+                         int len) {
   if (session_) {
     LOG(LS_ERROR) << "Failed to create SRTP session: "
                   << "SRTP session already created";
     return false;
   }
 
   if (!Init()) {
     return false;
   }
 
@@ skipping 12 matching lines @@
     return false;
   }
 
   if (!key || len != SRTP_MASTER_KEY_LEN) {
     LOG(LS_WARNING) << "Failed to create SRTP session: invalid key";
     return false;
   }
 
   policy.ssrc.type = static_cast<ssrc_type_t>(type);
   policy.ssrc.value = 0;
-  policy.key = const_cast<uint8*>(key);
+  policy.key = const_cast<uint8_t*>(key);
   // TODO(astor) parse window size from WSH session-param
   policy.window_size = 1024;
   policy.allow_repeat_tx = 1;
   // 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) {
@@ skipping 98 matching lines @@
 
 // On some systems, SRTP is not (yet) available.
 
 SrtpSession::SrtpSession() {
   LOG(WARNING) << "SRTP implementation is missing.";
 }
 
 SrtpSession::~SrtpSession() {
 }
 
-bool SrtpSession::SetSend(const std::string& cs, const uint8* key, int len) {
+bool SrtpSession::SetSend(const std::string& cs, const uint8_t* key, int len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
-bool SrtpSession::SetRecv(const std::string& cs, const uint8* key, int len) {
+bool SrtpSession::SetRecv(const std::string& cs, const uint8_t* key, int len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
 bool SrtpSession::ProtectRtp(void* data, int in_len, int max_len,
                              int* out_len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
 bool SrtpSession::ProtectRtcp(void* data, int in_len, int max_len,
                               int* out_len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
 bool SrtpSession::UnprotectRtp(void* data, int in_len, int* out_len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
 bool SrtpSession::UnprotectRtcp(void* data, int in_len, int* out_len) {
   return SrtpNotAvailable(__FUNCTION__);
 }
 
-void SrtpSession::set_signal_silent_time(uint32 signal_silent_time) {
+void SrtpSession::set_signal_silent_time(uint32_t signal_silent_time) {
   // Do nothing.
 }
 
 #endif  // HAVE_SRTP
 
 ///////////////////////////////////////////////////////////////////////////////
 // SrtpStat
 
 #ifdef HAVE_SRTP
 
 SrtpStat::SrtpStat()
     : signal_silent_time_(1000) {
 }
 
-void SrtpStat::AddProtectRtpResult(uint32 ssrc, int result) {
+void SrtpStat::AddProtectRtpResult(uint32_t ssrc, int result) {
   FailureKey key;
   key.ssrc = ssrc;
   key.mode = SrtpFilter::PROTECT;
   switch (result) {
     case err_status_ok:
       key.error = SrtpFilter::ERROR_NONE;
       break;
     case err_status_auth_fail:
       key.error = SrtpFilter::ERROR_AUTH;
       break;
     default:
       key.error = SrtpFilter::ERROR_FAIL;
   }
   HandleSrtpResult(key);
 }
 
-void SrtpStat::AddUnprotectRtpResult(uint32 ssrc, int result) {
+void SrtpStat::AddUnprotectRtpResult(uint32_t ssrc, int result) {
   FailureKey key;
   key.ssrc = ssrc;
   key.mode = SrtpFilter::UNPROTECT;
   switch (result) {
     case err_status_ok:
       key.error = SrtpFilter::ERROR_NONE;
       break;
     case err_status_auth_fail:
       key.error = SrtpFilter::ERROR_AUTH;
       break;
@@ skipping 15 matching lines @@
   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]);
-    uint32 current_time = rtc::Time();
+    uint32_t current_time = rtc::Time();
     if (stat->last_signal_time == 0 ||
         rtc::TimeDiff(current_time, stat->last_signal_time) >
         static_cast<int>(signal_silent_time_)) {
       SignalSrtpError(key.ssrc, key.mode, key.error);
       stat->last_signal_time = current_time;
     }
   }
 }
 
 #else   // !HAVE_SRTP
 
 // On some systems, SRTP is not (yet) available.
 
 SrtpStat::SrtpStat()
     : signal_silent_time_(1000) {
   LOG(WARNING) << "SRTP implementation is missing.";
 }
 
-void SrtpStat::AddProtectRtpResult(uint32 ssrc, int result) {
+void SrtpStat::AddProtectRtpResult(uint32_t ssrc, int result) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
-void SrtpStat::AddUnprotectRtpResult(uint32 ssrc, int result) {
+void SrtpStat::AddUnprotectRtpResult(uint32_t ssrc, int result) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 void SrtpStat::AddProtectRtcpResult(int result) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 void SrtpStat::AddUnprotectRtcpResult(int result) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 void SrtpStat::HandleSrtpResult(const SrtpStat::FailureKey& key) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 #endif  // HAVE_SRTP
 
 }  // namespace cricket