From 088fc585ed4872c5ce3aaa747f0c5000b7f2ed82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Joni=20R=C3=A4s=C3=A4nen?= Date: Mon, 16 May 2022 12:02:37 +0300 Subject: [PATCH] common: Add const qualifiers where applicable --- include/uvgrtp/context.hh | 2 +- include/uvgrtp/crypto.hh | 36 ++++++++++++------------ include/uvgrtp/media_stream.hh | 2 +- include/uvgrtp/rtcp.hh | 51 +++++++++++++--------------------- src/context.cc | 2 +- src/crypto.cc | 36 ++++++++++++------------ src/media_stream.cc | 2 +- src/reception_flow.cc | 2 +- src/reception_flow.hh | 2 +- src/rtcp.cc | 34 +++++++++++------------ src/srtp/base.cc | 2 +- src/srtp/base.hh | 2 +- src/srtp/srtp.cc | 2 +- src/srtp/srtp.hh | 2 +- 14 files changed, 82 insertions(+), 95 deletions(-) diff --git a/include/uvgrtp/context.hh b/include/uvgrtp/context.hh index 6e30903..a065f5e 100644 --- a/include/uvgrtp/context.hh +++ b/include/uvgrtp/context.hh @@ -80,7 +80,7 @@ namespace uvgrtp { private: /* Generate CNAME for participant using host and login names */ - std::string generate_cname(); + std::string generate_cname() const; /* CNAME is the same for all connections */ std::string cname_; diff --git a/include/uvgrtp/crypto.hh b/include/uvgrtp/crypto.hh index afcdbb6..da4c73a 100644 --- a/include/uvgrtp/crypto.hh +++ b/include/uvgrtp/crypto.hh @@ -52,10 +52,10 @@ namespace uvgrtp { namespace hmac { class sha1 { public: - sha1(uint8_t *key, size_t key_size); + sha1(const uint8_t *key, size_t key_size); ~sha1(); - void update(uint8_t *data, size_t len); + void update(const uint8_t *data, size_t len); void final(uint8_t *digest); /* truncate digest to "size" bytes */ @@ -69,10 +69,10 @@ namespace uvgrtp { class sha256 { public: - sha256(uint8_t *key, size_t key_size); + sha256(const uint8_t *key, size_t key_size); ~sha256(); - void update(uint8_t *data, size_t len); + void update(const uint8_t *data, size_t len); void final(uint8_t *digest); private: @@ -87,7 +87,7 @@ namespace uvgrtp { sha256(); ~sha256(); - void update(uint8_t *data, size_t len); + void update(const uint8_t *data, size_t len); void final(uint8_t *digest); private: @@ -100,11 +100,11 @@ namespace uvgrtp { class ecb { public: - ecb(uint8_t *key, size_t key_size); + ecb(const uint8_t *key, size_t key_size); ~ecb(); - void encrypt(uint8_t *output, uint8_t *input, size_t len); - void decrypt(uint8_t *output, uint8_t *input, size_t len); + void encrypt(uint8_t *output, const uint8_t *input, size_t len); + void decrypt(uint8_t *output, const uint8_t *input, size_t len); private: #ifdef __RTP_CRYPTO__ @@ -115,11 +115,11 @@ namespace uvgrtp { class cfb { public: - cfb(uint8_t *key, size_t key_size, uint8_t *iv); + cfb(const uint8_t *key, size_t key_size, const uint8_t *iv); ~cfb(); - void encrypt(uint8_t *output, uint8_t *input, size_t len); - void decrypt(uint8_t *output, uint8_t *input, size_t len); + void encrypt(uint8_t *output, const uint8_t *input, size_t len); + void decrypt(uint8_t *output, const uint8_t *input, size_t len); private: #ifdef __RTP_CRYPTO__ @@ -130,11 +130,11 @@ namespace uvgrtp { class ctr { public: - ctr(uint8_t *key, size_t key_size, uint8_t *iv); + ctr(const uint8_t *key, size_t key_size, const uint8_t *iv); ~ctr(); - void encrypt(uint8_t *output, uint8_t *input, size_t len); - void decrypt(uint8_t *output, uint8_t *input, size_t len); + void encrypt(uint8_t *output, const uint8_t *input, size_t len); + void decrypt(uint8_t *output, const uint8_t *input, size_t len); private: #ifdef __RTP_CRYPTO__ @@ -176,7 +176,7 @@ namespace uvgrtp { b32(); ~b32(); - void encode(uint8_t *input, uint8_t *output, size_t len); + void encode(const uint8_t *input, uint8_t *output, size_t len); private: #ifdef __RTP_CRYPTO__ @@ -189,9 +189,9 @@ namespace uvgrtp { } namespace crc32 { - void get_crc32(uint8_t *input, size_t len, uint32_t *output); - bool verify_crc32(uint8_t *input, size_t len, uint32_t old_crc); - uint32_t calculate_crc32(uint8_t *input, size_t len); + void get_crc32(const uint8_t *input, size_t len, uint32_t *output); + bool verify_crc32(const uint8_t *input, size_t len, uint32_t old_crc); + uint32_t calculate_crc32(const uint8_t *input, size_t len); } bool enabled(); diff --git a/include/uvgrtp/media_stream.hh b/include/uvgrtp/media_stream.hh index 5c09a94..9e942ec 100644 --- a/include/uvgrtp/media_stream.hh +++ b/include/uvgrtp/media_stream.hh @@ -279,7 +279,7 @@ namespace uvgrtp { /* Get unique key of the media stream * Used by session to index media streams */ - uint32_t get_key(); + uint32_t get_key() const; /// \endcond /** diff --git a/include/uvgrtp/rtcp.hh b/include/uvgrtp/rtcp.hh index c9e559f..e76fd90 100644 --- a/include/uvgrtp/rtcp.hh +++ b/include/uvgrtp/rtcp.hh @@ -119,7 +119,7 @@ namespace uvgrtp { * \retval RTP_MEMORY_ERROR If allocation fails * \retval RTP_GENERIC_ERROR If sending fails */ - rtp_error_t send_sdes_packet(std::vector& items); + rtp_error_t send_sdes_packet(const std::vector& items); /** * \brief Send an RTCP APP packet @@ -133,7 +133,7 @@ namespace uvgrtp { * \retval RTP_MEMORY_ERROR If allocation fails * \retval RTP_GENERIC_ERROR If sending fails */ - rtp_error_t send_app_packet(char *name, uint8_t subtype, size_t payload_len, uint8_t *payload); + rtp_error_t send_app_packet(const char *name, uint8_t subtype, size_t payload_len, const uint8_t *payload); /** * \brief Send an RTCP BYE packet @@ -175,22 +175,7 @@ namespace uvgrtp { rtp_error_t add_participant(std::string dst_addr, uint16_t dst_port, uint16_t src_port, uint32_t clock_rate); /* Functions for updating various RTP sender statistics */ - void sender_inc_seq_cycle_count(); - void sender_inc_sent_pkts(size_t n); - void sender_inc_sent_bytes(size_t n); - void sender_update_stats(uvgrtp::frame::rtp_frame *frame); - - void receiver_inc_sent_bytes(uint32_t sender_ssrc, size_t n); - void receiver_inc_overhead_bytes(uint32_t sender_ssrc, size_t n); - void receiver_inc_total_bytes(uint32_t sender_ssrc, size_t n); - void receiver_inc_sent_pkts(uint32_t sender_ssrc, size_t n); - - /* Update the RTCP statistics regarding this packet - * - * Return RTP_OK if packet is valid - * Return RTP_INVALID_VALUE if SSRCs of remotes have collided or the packet is invalid in some way - * return RTP_SSRC_COLLISION if our own SSRC has collided and we need to reinitialize it */ - rtp_error_t receiver_update_stats(uvgrtp::frame::rtp_frame *frame); + void sender_update_stats(const uvgrtp::frame::rtp_frame *frame); /* If we've detected that our SSRC has collided with someone else's SSRC, we need to * generate new random SSRC and reinitialize our own RTCP state. @@ -202,10 +187,10 @@ namespace uvgrtp { rtp_error_t reset_rtcp_state(uint32_t ssrc); /* Update various session statistics */ - void update_session_statistics(uvgrtp::frame::rtp_frame *frame); + void update_session_statistics(const uvgrtp::frame::rtp_frame *frame); /* Return SSRCs of all participants */ - std::vector get_participants(); + std::vector get_participants() const; /// \endcond /** @@ -318,7 +303,7 @@ namespace uvgrtp { /* when we start the RTCP instance, we don't know what the SSRC of the remote is * when an RTP packet is received, we must check if we've already received a packet * from this sender and if not, create new entry to receiver_stats_ map */ - bool is_participant(uint32_t ssrc); + bool is_participant(uint32_t ssrc) const; /* When we receive an RTP or RTCP packet, we need to check the source address and see if it's * the same address where we've received packets before. @@ -326,14 +311,14 @@ namespace uvgrtp { * If the address is new, it means we have detected an SSRC collision and the paket should * be dropped We also need to check whether this SSRC matches with our own SSRC and if it does * we need to send RTCP BYE and rejoin to the session */ - bool collision_detected(uint32_t ssrc, sockaddr_in& src_addr); + bool collision_detected(uint32_t ssrc, const sockaddr_in& src_addr) const; /* Move participant from initial_peers_ to participants_ */ rtp_error_t add_participant(uint32_t ssrc); /* We've got a message from new source (the SSRC of the frame is not known to us) * Initialize statistics for the peer and move it to participants_ */ - rtp_error_t init_new_participant(uvgrtp::frame::rtp_frame *frame); + rtp_error_t init_new_participant(const uvgrtp::frame::rtp_frame *frame); /* Initialize the RTP Sequence related stuff of peer * This function assumes that the peer already exists in the participants_ map */ @@ -364,8 +349,8 @@ namespace uvgrtp { uint16_t secondField, uvgrtp::frame::RTCP_FRAME_TYPE frame_type, bool addLocalSSRC); /* read the header values from rtcp packet */ - void read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header& header); - void read_reports(uint8_t* packet, size_t size, uint8_t count, bool has_sender_block, + void read_rtcp_header(const uint8_t* packet, uvgrtp::frame::rtcp_header& header); + void read_reports(const uint8_t* packet, size_t size, uint8_t count, bool has_sender_block, std::vector& reports); /* Takes ownership of the frame */ @@ -374,20 +359,17 @@ namespace uvgrtp { void free_participant(rtcp_participant* participant); - /* Pointer to RTP context from which clock rate etc. info is collected and which is - * used to change SSRC if a collision is detected */ - std::shared_ptr rtp_; - /* Secure RTCP context */ std::shared_ptr srtcp_; /* RTP context flags */ int flags_; - /* are we a sender or a receiver */ + /* are we a sender (and possible a receiver) or just a receiver */ int our_role_; /* TODO: time_t?? */ + // TODO: Check these, they don't seem to be used size_t tp_; /* the last time an RTCP packet was transmitted */ size_t tc_; /* the current time */ size_t tn_; /* the next scheduled transmission time of an RTCP packet */ @@ -399,19 +381,23 @@ namespace uvgrtp { * that will be used for RTCP packets by all members of this session, * in octets per second. This will be a specified fraction of the * "session bandwidth" parameter supplied to the application at startup. */ + // TODO: Not used anywhere at the moment size_t rtcp_bandwidth_; /* Flag that is true if the application has sent data since * the 2nd previous RTCP report was transmitted. */ + // TODO: Only set, never read bool we_sent_; /* The average compound RTCP packet size, in octets, * over all RTCP packets sent and received by this participant. The * size includes lower-layer transport and network protocol headers * (e.g., UDP and IP) as explained in Section 6.2 */ + // TODO: Only set, never read size_t avg_rtcp_pkt_pize_; /* Number of RTCP packets and bytes sent and received by this participant */ + // TODO: Only set, never read size_t rtcp_pkt_count_; size_t rtcp_byte_count_; @@ -419,10 +405,11 @@ namespace uvgrtp { uint32_t rtcp_pkt_sent_count_; /* Flag that is true if the application has not yet sent an RTCP packet. */ + // TODO: Only set, never read bool initial_; /* Copy of our own current SSRC */ - uint32_t ssrc_; + const uint32_t ssrc_; /* NTP timestamp associated with initial RTP timestamp (aka t = 0) */ uint64_t clock_start_; @@ -434,7 +421,7 @@ namespace uvgrtp { uint32_t rtp_ts_start_; std::map participants_; - uint8_t num_receivers_; // maximum is 32 (5 bits) + uint8_t num_receivers_; // maximum is 32 at the moment (5 bits) /* statistics for RTCP Sender and Receiver Reports */ struct sender_statistics our_stats; diff --git a/src/context.cc b/src/context.cc index 36d53a5..126376f 100644 --- a/src/context.cc +++ b/src/context.cc @@ -64,7 +64,7 @@ rtp_error_t uvgrtp::context::destroy_session(uvgrtp::session *session) return RTP_OK; } -std::string uvgrtp::context::generate_cname() +std::string uvgrtp::context::generate_cname() const { std::string host = uvgrtp::hostname::get_hostname(); std::string user = uvgrtp::hostname::get_username(); diff --git a/src/crypto.cc b/src/crypto.cc index bd483a9..4755815 100644 --- a/src/crypto.cc +++ b/src/crypto.cc @@ -7,7 +7,7 @@ /* ***************** hmac-sha1 ***************** */ -uvgrtp::crypto::hmac::sha1::sha1(uint8_t *key, size_t key_size) +uvgrtp::crypto::hmac::sha1::sha1(const uint8_t *key, size_t key_size) #ifdef __RTP_CRYPTO__ :hmac_(key, key_size) #endif @@ -21,7 +21,7 @@ uvgrtp::crypto::hmac::sha1::~sha1() { } -void uvgrtp::crypto::hmac::sha1::update(uint8_t *data, size_t len) +void uvgrtp::crypto::hmac::sha1::update(const uint8_t *data, size_t len) { #ifdef __RTP_CRYPTO__ hmac_.Update(data, len); @@ -62,7 +62,7 @@ void uvgrtp::crypto::hmac::sha1::final(uint8_t *digest, size_t size) /* ***************** hmac-sha256 ***************** */ -uvgrtp::crypto::hmac::sha256::sha256(uint8_t *key, size_t key_size) +uvgrtp::crypto::hmac::sha256::sha256(const uint8_t *key, size_t key_size) #ifdef __RTP_CRYPTO__ :hmac_(key, key_size) #endif @@ -76,7 +76,7 @@ uvgrtp::crypto::hmac::sha256::~sha256() { } -void uvgrtp::crypto::hmac::sha256::update(uint8_t *data, size_t len) +void uvgrtp::crypto::hmac::sha256::update(const uint8_t *data, size_t len) { #ifdef __RTP_CRYPTO__ hmac_.Update(data, len); @@ -113,7 +113,7 @@ uvgrtp::crypto::sha256::~sha256() { } -void uvgrtp::crypto::sha256::update(uint8_t *data, size_t len) +void uvgrtp::crypto::sha256::update(const uint8_t *data, size_t len) { #ifdef __RTP_CRYPTO__ sha_.Update(data, len); @@ -139,7 +139,7 @@ void uvgrtp::crypto::sha256::final(uint8_t *digest) /* ***************** aes-128 ***************** */ -uvgrtp::crypto::aes::ctr::ctr(uint8_t *key, size_t key_size, uint8_t *iv) +uvgrtp::crypto::aes::ctr::ctr(const uint8_t *key, size_t key_size, const uint8_t *iv) #ifdef __RTP_CRYPTO__ :enc_(key, key_size, iv), dec_(key, key_size, iv) @@ -154,7 +154,7 @@ uvgrtp::crypto::aes::ctr::~ctr() { } -void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ enc_.ProcessData(output, input, len); @@ -166,7 +166,7 @@ void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, uint8_t *input, size_t l #endif } -void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ dec_.ProcessData(output, input, len); @@ -178,7 +178,7 @@ void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, uint8_t *input, size_t l #endif } -uvgrtp::crypto::aes::cfb::cfb(uint8_t *key, size_t key_size, uint8_t *iv) +uvgrtp::crypto::aes::cfb::cfb(const uint8_t *key, size_t key_size, const uint8_t *iv) #ifdef __RTP_CRYPTO__ :enc_(key, key_size, iv), dec_(key, key_size, iv) @@ -193,7 +193,7 @@ uvgrtp::crypto::aes::cfb::~cfb() { } -void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ enc_.ProcessData(output, input, len); @@ -205,7 +205,7 @@ void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, uint8_t *input, size_t l #endif } -void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ dec_.ProcessData(output, input, len); @@ -217,7 +217,7 @@ void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, uint8_t *input, size_t l #endif } -uvgrtp::crypto::aes::ecb::ecb(uint8_t *key, size_t key_size) +uvgrtp::crypto::aes::ecb::ecb(const uint8_t *key, size_t key_size) #ifdef __RTP_CRYPTO__ :enc_(key, key_size), dec_(key, key_size) @@ -232,7 +232,7 @@ uvgrtp::crypto::aes::ecb::~ecb() { } -void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ enc_.ProcessData(output, input, len); @@ -244,7 +244,7 @@ void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, uint8_t *input, size_t l #endif } -void uvgrtp::crypto::aes::ecb::decrypt(uint8_t *output, uint8_t *input, size_t len) +void uvgrtp::crypto::aes::ecb::decrypt(uint8_t *output, const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ dec_.ProcessData(output, input, len); @@ -382,7 +382,7 @@ uvgrtp::crypto::b32::~b32() { } -void uvgrtp::crypto::b32::encode(uint8_t *input, uint8_t *output, size_t len) +void uvgrtp::crypto::b32::encode(const uint8_t *input, uint8_t *output, size_t len) { #ifdef __RTP_CRYPTO__ enc_.Put(input, len); @@ -418,7 +418,7 @@ void uvgrtp::crypto::random::generate_random(uint8_t *out, size_t len) /* ***************** crc32 ***************** */ -void uvgrtp::crypto::crc32::get_crc32(uint8_t *input, size_t len, uint32_t *output) +void uvgrtp::crypto::crc32::get_crc32(const uint8_t *input, size_t len, uint32_t *output) { #ifdef __RTP_CRYPTO__ CryptoPP::CRC32 crc32; @@ -433,7 +433,7 @@ void uvgrtp::crypto::crc32::get_crc32(uint8_t *input, size_t len, uint32_t *outp #endif } -uint32_t uvgrtp::crypto::crc32::calculate_crc32(uint8_t *input, size_t len) +uint32_t uvgrtp::crypto::crc32::calculate_crc32(const uint8_t *input, size_t len) { #ifdef __RTP_CRYPTO__ CryptoPP::CRC32 crc32; @@ -451,7 +451,7 @@ uint32_t uvgrtp::crypto::crc32::calculate_crc32(uint8_t *input, size_t len) #endif } -bool uvgrtp::crypto::crc32::verify_crc32(uint8_t *input, size_t len, uint32_t old_crc) +bool uvgrtp::crypto::crc32::verify_crc32(const uint8_t *input, size_t len, uint32_t old_crc) { #ifdef __RTP_CRYPTO__ CryptoPP::CRC32 crc32; diff --git a/src/media_stream.cc b/src/media_stream.cc index 9993eb2..9c7b3b8 100644 --- a/src/media_stream.cc +++ b/src/media_stream.cc @@ -574,7 +574,7 @@ rtp_error_t uvgrtp::media_stream::configure_ctx(int flag, ssize_t value) return ret; } -uint32_t uvgrtp::media_stream::get_key() +uint32_t uvgrtp::media_stream::get_key() const { return key_; } diff --git a/src/reception_flow.cc b/src/reception_flow.cc index 778046f..5d64a86 100644 --- a/src/reception_flow.cc +++ b/src/reception_flow.cc @@ -75,7 +75,7 @@ void uvgrtp::reception_flow::destroy_ring_buffer() ring_buffer_.clear(); } -void uvgrtp::reception_flow::set_buffer_size(ssize_t& value) +void uvgrtp::reception_flow::set_buffer_size(const ssize_t& value) { buffer_size_kbytes_ = value; create_ring_buffer(); diff --git a/src/reception_flow.hh b/src/reception_flow.hh index a48859d..1cd0c1e 100644 --- a/src/reception_flow.hh +++ b/src/reception_flow.hh @@ -145,7 +145,7 @@ namespace uvgrtp { uvgrtp::frame::rtp_frame *pull_frame(); uvgrtp::frame::rtp_frame *pull_frame(size_t timeout_ms); - void set_buffer_size(ssize_t& value); + void set_buffer_size(const ssize_t& value); private: /* RTP packet receiver thread */ diff --git a/src/rtcp.cc b/src/rtcp.cc index 25e8a5d..fedbd33 100644 --- a/src/rtcp.cc +++ b/src/rtcp.cc @@ -36,11 +36,12 @@ constexpr int ESTIMATED_MAX_RECEPTION_TIME_MS = 10; const uint32_t MAX_SUPPORTED_PARTICIPANTS = 31; uvgrtp::rtcp::rtcp(std::shared_ptr rtp, int flags): - rtp_(rtp), flags_(flags), our_role_(RECEIVER), + flags_(flags), our_role_(RECEIVER), tp_(0), tc_(0), tn_(0), pmembers_(0), members_(0), senders_(0), rtcp_bandwidth_(0), - we_sent_(0), avg_rtcp_pkt_pize_(0), rtcp_pkt_count_(0), - rtcp_pkt_sent_count_(0), initial_(true), num_receivers_(0), + we_sent_(false), avg_rtcp_pkt_pize_(0), rtcp_pkt_count_(0), + rtcp_pkt_sent_count_(0), initial_(true), ssrc_(rtp->get_ssrc()), + num_receivers_(0), sender_hook_(nullptr), receiver_hook_(nullptr), sdes_hook_(nullptr), @@ -55,7 +56,6 @@ uvgrtp::rtcp::rtcp(std::shared_ptr rtp, int flags): app_hook_u_(nullptr), active_(false) { - ssrc_ = rtp->get_ssrc(); clock_rate_ = rtp->get_clock_rate(); clock_start_ = 0; @@ -595,7 +595,7 @@ std::vector& uvgrtp::rtcp::get_sockets() return sockets_; } -std::vector uvgrtp::rtcp::get_participants() +std::vector uvgrtp::rtcp::get_participants() const { std::vector ssrcs; @@ -645,7 +645,7 @@ void uvgrtp::rtcp::zero_stats(uvgrtp::receiver_statistics *stats) stats->cycles = 0; } -bool uvgrtp::rtcp::is_participant(uint32_t ssrc) +bool uvgrtp::rtcp::is_participant(uint32_t ssrc) const { return participants_.find(ssrc) != participants_.end(); } @@ -657,7 +657,7 @@ void uvgrtp::rtcp::set_ts_info(uint64_t clock_start, uint32_t clock_rate, uint32 rtp_ts_start_ = rtp_ts_start; } -void uvgrtp::rtcp::sender_update_stats(uvgrtp::frame::rtp_frame *frame) +void uvgrtp::rtcp::sender_update_stats(const uvgrtp::frame::rtp_frame *frame) { if (!frame) { @@ -675,7 +675,7 @@ void uvgrtp::rtcp::sender_update_stats(uvgrtp::frame::rtp_frame *frame) our_stats.sent_rtp_packet = true; } -rtp_error_t uvgrtp::rtcp::init_new_participant(uvgrtp::frame::rtp_frame *frame) +rtp_error_t uvgrtp::rtcp::init_new_participant(const uvgrtp::frame::rtp_frame *frame) { rtp_error_t ret; @@ -809,14 +809,14 @@ rtp_error_t uvgrtp::rtcp::reset_rtcp_state(uint32_t ssrc) return RTP_OK; } -bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, sockaddr_in& src_addr) +bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, const sockaddr_in& src_addr) const { if (participants_.find(ssrc) == participants_.end()) { return false; } - auto sender = participants_[ssrc]; + auto sender = participants_.at(ssrc); if (src_addr.sin_port != sender->address.sin_port && src_addr.sin_addr.s_addr != sender->address.sin_addr.s_addr) @@ -827,7 +827,7 @@ bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, sockaddr_in& src_addr) return false; } -void uvgrtp::rtcp::update_session_statistics(uvgrtp::frame::rtp_frame *frame) +void uvgrtp::rtcp::update_session_statistics(const uvgrtp::frame::rtp_frame *frame) { auto p = participants_[frame->header.ssrc]; @@ -1137,7 +1137,7 @@ rtp_error_t uvgrtp::rtcp::handle_app_packet(uint8_t* packet, size_t size, return RTP_OK; } -rtp_error_t uvgrtp::rtcp::handle_receiver_report_packet(uint8_t* packet, size_t size, +rtp_error_t uvgrtp::rtcp::handle_receiver_report_packet(uint8_t* packet, size_t size, uvgrtp::frame::rtcp_header& header) { if (!packet || !size) @@ -1286,7 +1286,7 @@ rtp_error_t uvgrtp::rtcp::construct_rtcp_header(size_t packet_size, return RTP_OK; } -void uvgrtp::rtcp::read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header& header) +void uvgrtp::rtcp::read_rtcp_header(const uint8_t* packet, uvgrtp::frame::rtcp_header& header) { header.version = (packet[0] >> 6) & 0x3; header.padding = (packet[0] >> 5) & 0x1; @@ -1303,7 +1303,7 @@ void uvgrtp::rtcp::read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header& header.length = ntohs(*(uint16_t*)&packet[2]); } -void uvgrtp::rtcp::read_reports(uint8_t* packet, size_t size, uint8_t count, bool has_sender_block, +void uvgrtp::rtcp::read_reports(const uint8_t* packet, size_t size, uint8_t count, bool has_sender_block, std::vector& reports) { uint32_t report_section = RTCP_HEADER_SIZE + SSRC_CSRC_SIZE; @@ -1463,7 +1463,7 @@ rtp_error_t uvgrtp::rtcp::generate_report() return send_rtcp_packet_to_participants(frame, frame_size); } -rtp_error_t uvgrtp::rtcp::send_sdes_packet(std::vector& items) +rtp_error_t uvgrtp::rtcp::send_sdes_packet(const std::vector& items) { if (items.empty()) { @@ -1540,8 +1540,8 @@ rtp_error_t uvgrtp::rtcp::send_bye_packet(std::vector ssrcs) return send_rtcp_packet_to_participants(frame, frame_size); } -rtp_error_t uvgrtp::rtcp::send_app_packet(char* name, uint8_t subtype, - size_t payload_len, uint8_t* payload) +rtp_error_t uvgrtp::rtcp::send_app_packet(const char* name, uint8_t subtype, + size_t payload_len, const uint8_t* payload) { rtp_error_t ret = RTP_OK; uint8_t* frame = nullptr; diff --git a/src/srtp/base.cc b/src/srtp/base.cc index df4e0b6..964788e 100644 --- a/src/srtp/base.cc +++ b/src/srtp/base.cc @@ -212,7 +212,7 @@ rtp_error_t uvgrtp::base_srtp::allocate_crypto_ctx(size_t key_size) return RTP_OK; } -size_t uvgrtp::base_srtp::get_key_size(int flags) +size_t uvgrtp::base_srtp::get_key_size(int flags) const { size_t key_size = AES128_KEY_SIZE; diff --git a/src/srtp/base.hh b/src/srtp/base.hh index 728de9e..d1ae647 100644 --- a/src/srtp/base.hh +++ b/src/srtp/base.hh @@ -148,7 +148,7 @@ namespace uvgrtp { * Returns false if replay protection has not been enabled */ bool is_replayed_packet(uint8_t *digest); - size_t get_key_size(int flags); + size_t get_key_size(int flags) const; protected: diff --git a/src/srtp/srtp.cc b/src/srtp/srtp.cc index 727ae0e..cb21438 100644 --- a/src/srtp/srtp.cc +++ b/src/srtp/srtp.cc @@ -151,7 +151,7 @@ authenticate: return ret; } -bool uvgrtp::srtp::authenticate_rtp() +bool uvgrtp::srtp::authenticate_rtp() const { return authenticate_rtp_; } diff --git a/src/srtp/srtp.hh b/src/srtp/srtp.hh index d0852a2..94f2773 100644 --- a/src/srtp/srtp.hh +++ b/src/srtp/srtp.hh @@ -24,7 +24,7 @@ namespace uvgrtp { rtp_error_t encrypt(uint32_t ssrc, uint16_t seq, uint8_t* buffer, size_t len); /* Has RTP packet authentication been enabled? */ - bool authenticate_rtp(); + bool authenticate_rtp() const; /* By default RTP packet authentication is disabled but by * giving RCE_SRTP_AUTHENTICATE_RTP to create_stream() user can enable it.