henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 2 | * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 11 | #include "media/base/rtp_utils.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 12 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 13 | #include <string.h> |
| 14 | #include <vector> |
| 15 | |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 16 | // PacketTimeUpdateParams is defined in asyncpacketsocket.h. |
| 17 | // TODO(sergeyu): Find more appropriate place for PacketTimeUpdateParams. |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 18 | #include "media/base/turn_utils.h" |
| 19 | #include "rtc_base/async_packet_socket.h" |
| 20 | #include "rtc_base/byte_order.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 21 | #include "rtc_base/checks.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 22 | #include "rtc_base/message_digest.h" |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 23 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 24 | namespace cricket { |
| 25 | |
pkasting@chromium.org | 0e81fdf | 2015-02-02 23:54:03 +0000 | [diff] [blame] | 26 | static const uint8_t kRtpVersion = 2; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 27 | static const size_t kRtpFlagsOffset = 0; |
| 28 | static const size_t kRtpPayloadTypeOffset = 1; |
| 29 | static const size_t kRtpSeqNumOffset = 2; |
| 30 | static const size_t kRtpTimestampOffset = 4; |
| 31 | static const size_t kRtpSsrcOffset = 8; |
| 32 | static const size_t kRtcpPayloadTypeOffset = 1; |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 33 | static const size_t kRtpExtensionHeaderLen = 4; |
| 34 | static const size_t kAbsSendTimeExtensionLen = 3; |
| 35 | static const size_t kOneByteExtensionHeaderLen = 1; |
| 36 | |
| 37 | namespace { |
| 38 | |
| 39 | // Fake auth tag written by the sender when external authentication is enabled. |
| 40 | // HMAC in packet will be compared against this value before updating packet |
| 41 | // with actual HMAC value. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 42 | static const uint8_t kFakeAuthTag[10] = {0xba, 0xdd, 0xba, 0xdd, 0xba, |
| 43 | 0xdd, 0xba, 0xdd, 0xba, 0xdd}; |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 44 | |
| 45 | void UpdateAbsSendTimeExtensionValue(uint8_t* extension_data, |
| 46 | size_t length, |
| 47 | uint64_t time_us) { |
| 48 | // Absolute send time in RTP streams. |
| 49 | // |
| 50 | // The absolute send time is signaled to the receiver in-band using the |
| 51 | // general mechanism for RTP header extensions [RFC5285]. The payload |
| 52 | // of this extension (the transmitted value) is a 24-bit unsigned integer |
| 53 | // containing the sender's current time in seconds as a fixed point number |
| 54 | // with 18 bits fractional part. |
| 55 | // |
| 56 | // The form of the absolute send time extension block: |
| 57 | // |
| 58 | // 0 1 2 3 |
| 59 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| 60 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 61 | // | ID | len=2 | absolute send time | |
| 62 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 63 | if (length != kAbsSendTimeExtensionLen) { |
| 64 | RTC_NOTREACHED(); |
| 65 | return; |
| 66 | } |
| 67 | |
| 68 | // Convert microseconds to a 6.18 fixed point value in seconds. |
| 69 | uint32_t send_time = ((time_us << 18) / 1000000) & 0x00FFFFFF; |
| 70 | extension_data[0] = static_cast<uint8_t>(send_time >> 16); |
| 71 | extension_data[1] = static_cast<uint8_t>(send_time >> 8); |
| 72 | extension_data[2] = static_cast<uint8_t>(send_time); |
| 73 | } |
| 74 | |
| 75 | // Assumes |length| is actual packet length + tag length. Updates HMAC at end of |
| 76 | // the RTP packet. |
| 77 | void UpdateRtpAuthTag(uint8_t* rtp, |
| 78 | size_t length, |
| 79 | const rtc::PacketTimeUpdateParams& packet_time_params) { |
| 80 | // If there is no key, return. |
| 81 | if (packet_time_params.srtp_auth_key.empty()) { |
| 82 | return; |
| 83 | } |
| 84 | |
| 85 | size_t tag_length = packet_time_params.srtp_auth_tag_len; |
| 86 | |
| 87 | // ROC (rollover counter) is at the beginning of the auth tag. |
| 88 | const size_t kRocLength = 4; |
| 89 | if (tag_length < kRocLength || tag_length > length) { |
| 90 | RTC_NOTREACHED(); |
| 91 | return; |
| 92 | } |
| 93 | |
| 94 | uint8_t* auth_tag = rtp + (length - tag_length); |
| 95 | |
| 96 | // We should have a fake HMAC value @ auth_tag. |
| 97 | RTC_DCHECK_EQ(0, memcmp(auth_tag, kFakeAuthTag, tag_length)); |
| 98 | |
| 99 | // Copy ROC after end of rtp packet. |
| 100 | memcpy(auth_tag, &packet_time_params.srtp_packet_index, kRocLength); |
| 101 | // Authentication of a RTP packet will have RTP packet + ROC size. |
| 102 | size_t auth_required_length = length - tag_length + kRocLength; |
| 103 | |
| 104 | uint8_t output[64]; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 105 | size_t result = |
| 106 | rtc::ComputeHmac(rtc::DIGEST_SHA_1, &packet_time_params.srtp_auth_key[0], |
| 107 | packet_time_params.srtp_auth_key.size(), rtp, |
| 108 | auth_required_length, output, sizeof(output)); |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 109 | |
| 110 | if (result < tag_length) { |
| 111 | RTC_NOTREACHED(); |
| 112 | return; |
| 113 | } |
| 114 | |
| 115 | // Copy HMAC from output to packet. This is required as auth tag length |
| 116 | // may not be equal to the actual HMAC length. |
| 117 | memcpy(auth_tag, output, tag_length); |
| 118 | } |
| 119 | |
Steve Anton | e78bcb9 | 2017-10-31 09:53:08 -0700 | [diff] [blame] | 120 | } // namespace |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 121 | |
| 122 | bool GetUint8(const void* data, size_t offset, int* value) { |
| 123 | if (!data || !value) { |
| 124 | return false; |
| 125 | } |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 126 | *value = *(static_cast<const uint8_t*>(data) + offset); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 127 | return true; |
| 128 | } |
| 129 | |
| 130 | bool GetUint16(const void* data, size_t offset, int* value) { |
| 131 | if (!data || !value) { |
| 132 | return false; |
| 133 | } |
| 134 | *value = static_cast<int>( |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 135 | rtc::GetBE16(static_cast<const uint8_t*>(data) + offset)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 136 | return true; |
| 137 | } |
| 138 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 139 | bool GetUint32(const void* data, size_t offset, uint32_t* value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 140 | if (!data || !value) { |
| 141 | return false; |
| 142 | } |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 143 | *value = rtc::GetBE32(static_cast<const uint8_t*>(data) + offset); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 144 | return true; |
| 145 | } |
| 146 | |
pkasting@chromium.org | 0e81fdf | 2015-02-02 23:54:03 +0000 | [diff] [blame] | 147 | bool SetUint8(void* data, size_t offset, uint8_t value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 148 | if (!data) { |
| 149 | return false; |
| 150 | } |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 151 | rtc::Set8(data, offset, value); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 152 | return true; |
| 153 | } |
| 154 | |
pkasting@chromium.org | 0e81fdf | 2015-02-02 23:54:03 +0000 | [diff] [blame] | 155 | bool SetUint16(void* data, size_t offset, uint16_t value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 156 | if (!data) { |
| 157 | return false; |
| 158 | } |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 159 | rtc::SetBE16(static_cast<uint8_t*>(data) + offset, value); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 160 | return true; |
| 161 | } |
| 162 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 163 | bool SetUint32(void* data, size_t offset, uint32_t value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 164 | if (!data) { |
| 165 | return false; |
| 166 | } |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 167 | rtc::SetBE32(static_cast<uint8_t*>(data) + offset, value); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 168 | return true; |
| 169 | } |
| 170 | |
| 171 | bool GetRtpFlags(const void* data, size_t len, int* value) { |
| 172 | if (len < kMinRtpPacketLen) { |
| 173 | return false; |
| 174 | } |
| 175 | return GetUint8(data, kRtpFlagsOffset, value); |
| 176 | } |
| 177 | |
| 178 | bool GetRtpPayloadType(const void* data, size_t len, int* value) { |
| 179 | if (len < kMinRtpPacketLen) { |
| 180 | return false; |
| 181 | } |
| 182 | if (!GetUint8(data, kRtpPayloadTypeOffset, value)) { |
| 183 | return false; |
| 184 | } |
| 185 | *value &= 0x7F; |
| 186 | return true; |
| 187 | } |
| 188 | |
| 189 | bool GetRtpSeqNum(const void* data, size_t len, int* value) { |
| 190 | if (len < kMinRtpPacketLen) { |
| 191 | return false; |
| 192 | } |
| 193 | return GetUint16(data, kRtpSeqNumOffset, value); |
| 194 | } |
| 195 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 196 | bool GetRtpTimestamp(const void* data, size_t len, uint32_t* value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 197 | if (len < kMinRtpPacketLen) { |
| 198 | return false; |
| 199 | } |
| 200 | return GetUint32(data, kRtpTimestampOffset, value); |
| 201 | } |
| 202 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 203 | bool GetRtpSsrc(const void* data, size_t len, uint32_t* value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 204 | if (len < kMinRtpPacketLen) { |
| 205 | return false; |
| 206 | } |
| 207 | return GetUint32(data, kRtpSsrcOffset, value); |
| 208 | } |
| 209 | |
| 210 | bool GetRtpHeaderLen(const void* data, size_t len, size_t* value) { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 211 | if (!data || len < kMinRtpPacketLen || !value) |
| 212 | return false; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 213 | const uint8_t* header = static_cast<const uint8_t*>(data); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 214 | // Get base header size + length of CSRCs (not counting extension yet). |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 215 | size_t header_size = kMinRtpPacketLen + (header[0] & 0xF) * sizeof(uint32_t); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 216 | if (len < header_size) |
| 217 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 218 | // If there's an extension, read and add in the extension size. |
| 219 | if (header[0] & 0x10) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 220 | if (len < header_size + sizeof(uint32_t)) |
| 221 | return false; |
| 222 | header_size += |
| 223 | ((rtc::GetBE16(header + header_size + 2) + 1) * sizeof(uint32_t)); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 224 | if (len < header_size) |
| 225 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 226 | } |
| 227 | *value = header_size; |
| 228 | return true; |
| 229 | } |
| 230 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 231 | bool GetRtpHeader(const void* data, size_t len, RtpHeader* header) { |
| 232 | return (GetRtpPayloadType(data, len, &(header->payload_type)) && |
| 233 | GetRtpSeqNum(data, len, &(header->seq_num)) && |
| 234 | GetRtpTimestamp(data, len, &(header->timestamp)) && |
| 235 | GetRtpSsrc(data, len, &(header->ssrc))); |
| 236 | } |
| 237 | |
| 238 | bool GetRtcpType(const void* data, size_t len, int* value) { |
| 239 | if (len < kMinRtcpPacketLen) { |
| 240 | return false; |
| 241 | } |
| 242 | return GetUint8(data, kRtcpPayloadTypeOffset, value); |
| 243 | } |
| 244 | |
| 245 | // This method returns SSRC first of RTCP packet, except if packet is SDES. |
| 246 | // TODO(mallinath) - Fully implement RFC 5506. This standard doesn't restrict |
| 247 | // to send non-compound packets only to feedback messages. |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 248 | bool GetRtcpSsrc(const void* data, size_t len, uint32_t* value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 249 | // Packet should be at least of 8 bytes, to get SSRC from a RTCP packet. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 250 | if (!data || len < kMinRtcpPacketLen + 4 || !value) |
| 251 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 252 | int pl_type; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 253 | if (!GetRtcpType(data, len, &pl_type)) |
| 254 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 255 | // SDES packet parsing is not supported. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 256 | if (pl_type == kRtcpTypeSDES) |
| 257 | return false; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 258 | *value = rtc::GetBE32(static_cast<const uint8_t*>(data) + 4); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 259 | return true; |
| 260 | } |
| 261 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 262 | bool SetRtpSsrc(void* data, size_t len, uint32_t value) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 263 | return SetUint32(data, kRtpSsrcOffset, value); |
| 264 | } |
| 265 | |
| 266 | // Assumes version 2, no padding, no extensions, no csrcs. |
| 267 | bool SetRtpHeader(void* data, size_t len, const RtpHeader& header) { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 268 | if (!IsValidRtpPayloadType(header.payload_type) || header.seq_num < 0 || |
| 269 | header.seq_num > static_cast<int>(UINT16_MAX)) { |
pkasting@chromium.org | 0e81fdf | 2015-02-02 23:54:03 +0000 | [diff] [blame] | 270 | return false; |
| 271 | } |
| 272 | return (SetUint8(data, kRtpFlagsOffset, kRtpVersion << 6) && |
| 273 | SetUint8(data, kRtpPayloadTypeOffset, header.payload_type & 0x7F) && |
| 274 | SetUint16(data, kRtpSeqNumOffset, |
| 275 | static_cast<uint16_t>(header.seq_num)) && |
| 276 | SetUint32(data, kRtpTimestampOffset, header.timestamp) && |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 277 | SetRtpSsrc(data, len, header.ssrc)); |
| 278 | } |
| 279 | |
buildbot@webrtc.org | 1ef789d | 2014-06-19 23:54:12 +0000 | [diff] [blame] | 280 | bool IsRtpPacket(const void* data, size_t len) { |
| 281 | if (len < kMinRtpPacketLen) |
| 282 | return false; |
| 283 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 284 | return (static_cast<const uint8_t*>(data)[0] >> 6) == kRtpVersion; |
buildbot@webrtc.org | 1ef789d | 2014-06-19 23:54:12 +0000 | [diff] [blame] | 285 | } |
| 286 | |
Zhi Huang | 365381f | 2018-04-13 16:44:34 -0700 | [diff] [blame] | 287 | // Check the RTP payload type. If 63 < payload type < 96, it's RTCP. |
| 288 | // For additional details, see http://tools.ietf.org/html/rfc5761. |
| 289 | bool IsRtcpPacket(const char* data, size_t len) { |
Piotr (Peter) Slatala | 042bb00 | 2019-01-30 14:57:12 -0800 | [diff] [blame^] | 290 | if (len < kMinRtcpPacketLen) { |
Zhi Huang | 365381f | 2018-04-13 16:44:34 -0700 | [diff] [blame] | 291 | return false; |
| 292 | } |
Piotr (Peter) Slatala | 042bb00 | 2019-01-30 14:57:12 -0800 | [diff] [blame^] | 293 | |
| 294 | // RTCP must be a valid RTP packet. |
| 295 | if ((static_cast<uint8_t>(data[0]) >> 6) != kRtpVersion) { |
| 296 | return false; |
| 297 | } |
| 298 | |
Zhi Huang | 365381f | 2018-04-13 16:44:34 -0700 | [diff] [blame] | 299 | char pt = data[1] & 0x7F; |
| 300 | return (63 < pt) && (pt < 96); |
| 301 | } |
| 302 | |
pkasting@chromium.org | e9facf8 | 2015-02-17 20:36:28 +0000 | [diff] [blame] | 303 | bool IsValidRtpPayloadType(int payload_type) { |
| 304 | return payload_type >= 0 && payload_type <= 127; |
| 305 | } |
| 306 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 307 | bool IsValidRtpRtcpPacketSize(bool rtcp, size_t size) { |
| 308 | return (rtcp ? size >= kMinRtcpPacketLen : size >= kMinRtpPacketLen) && |
| 309 | size <= kMaxRtpPacketLen; |
| 310 | } |
| 311 | |
| 312 | const char* RtpRtcpStringLiteral(bool rtcp) { |
| 313 | return rtcp ? "RTCP" : "RTP"; |
| 314 | } |
| 315 | |
Sergey Ulanov | dc305db | 2016-01-14 17:14:54 -0800 | [diff] [blame] | 316 | bool ValidateRtpHeader(const uint8_t* rtp, |
| 317 | size_t length, |
| 318 | size_t* header_length) { |
| 319 | if (header_length) { |
| 320 | *header_length = 0; |
| 321 | } |
| 322 | |
| 323 | if (length < kMinRtpPacketLen) { |
| 324 | return false; |
| 325 | } |
| 326 | |
| 327 | size_t cc_count = rtp[0] & 0x0F; |
| 328 | size_t header_length_without_extension = kMinRtpPacketLen + 4 * cc_count; |
| 329 | if (header_length_without_extension > length) { |
| 330 | return false; |
| 331 | } |
| 332 | |
| 333 | // If extension bit is not set, we are done with header processing, as input |
| 334 | // length is verified above. |
| 335 | if (!(rtp[0] & 0x10)) { |
| 336 | if (header_length) |
| 337 | *header_length = header_length_without_extension; |
| 338 | |
| 339 | return true; |
| 340 | } |
| 341 | |
| 342 | rtp += header_length_without_extension; |
| 343 | |
| 344 | if (header_length_without_extension + kRtpExtensionHeaderLen > length) { |
| 345 | return false; |
| 346 | } |
| 347 | |
| 348 | // Getting extension profile length. |
| 349 | // Length is in 32 bit words. |
| 350 | uint16_t extension_length_in_32bits = rtc::GetBE16(rtp + 2); |
| 351 | size_t extension_length = extension_length_in_32bits * 4; |
| 352 | |
| 353 | size_t rtp_header_length = extension_length + |
| 354 | header_length_without_extension + |
| 355 | kRtpExtensionHeaderLen; |
| 356 | |
| 357 | // Verify input length against total header size. |
| 358 | if (rtp_header_length > length) { |
| 359 | return false; |
| 360 | } |
| 361 | |
| 362 | if (header_length) { |
| 363 | *header_length = rtp_header_length; |
| 364 | } |
| 365 | return true; |
| 366 | } |
| 367 | |
| 368 | // ValidateRtpHeader() must be called before this method to make sure, we have |
| 369 | // a sane rtp packet. |
| 370 | bool UpdateRtpAbsSendTimeExtension(uint8_t* rtp, |
| 371 | size_t length, |
| 372 | int extension_id, |
| 373 | uint64_t time_us) { |
| 374 | // 0 1 2 3 |
| 375 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| 376 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 377 | // |V=2|P|X| CC |M| PT | sequence number | |
| 378 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 379 | // | timestamp | |
| 380 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 381 | // | synchronization source (SSRC) identifier | |
| 382 | // +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
| 383 | // | contributing source (CSRC) identifiers | |
| 384 | // | .... | |
| 385 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 386 | |
| 387 | // Return if extension bit is not set. |
| 388 | if (!(rtp[0] & 0x10)) { |
| 389 | return true; |
| 390 | } |
| 391 | |
| 392 | size_t cc_count = rtp[0] & 0x0F; |
| 393 | size_t header_length_without_extension = kMinRtpPacketLen + 4 * cc_count; |
| 394 | |
| 395 | rtp += header_length_without_extension; |
| 396 | |
| 397 | // Getting extension profile ID and length. |
| 398 | uint16_t profile_id = rtc::GetBE16(rtp); |
| 399 | // Length is in 32 bit words. |
| 400 | uint16_t extension_length_in_32bits = rtc::GetBE16(rtp + 2); |
| 401 | size_t extension_length = extension_length_in_32bits * 4; |
| 402 | |
| 403 | rtp += kRtpExtensionHeaderLen; // Moving past extension header. |
| 404 | |
| 405 | bool found = false; |
| 406 | // WebRTC is using one byte header extension. |
| 407 | // TODO(mallinath) - Handle two byte header extension. |
| 408 | if (profile_id == 0xBEDE) { // OneByte extension header |
| 409 | // 0 |
| 410 | // 0 1 2 3 4 5 6 7 |
| 411 | // +-+-+-+-+-+-+-+-+ |
| 412 | // | ID |length | |
| 413 | // +-+-+-+-+-+-+-+-+ |
| 414 | |
| 415 | // 0 1 2 3 |
| 416 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| 417 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 418 | // | 0xBE | 0xDE | length=3 | |
| 419 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 420 | // | ID | L=0 | data | ID | L=1 | data... |
| 421 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 422 | // ...data | 0 (pad) | 0 (pad) | ID | L=3 | |
| 423 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 424 | // | data | |
| 425 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 426 | const uint8_t* extension_start = rtp; |
| 427 | const uint8_t* extension_end = extension_start + extension_length; |
| 428 | |
| 429 | while (rtp < extension_end) { |
| 430 | const int id = (*rtp & 0xF0) >> 4; |
| 431 | const size_t length = (*rtp & 0x0F) + 1; |
| 432 | if (rtp + kOneByteExtensionHeaderLen + length > extension_end) { |
| 433 | return false; |
| 434 | } |
| 435 | // The 4-bit length is the number minus one of data bytes of this header |
| 436 | // extension element following the one-byte header. |
| 437 | if (id == extension_id) { |
| 438 | UpdateAbsSendTimeExtensionValue(rtp + kOneByteExtensionHeaderLen, |
| 439 | length, time_us); |
| 440 | found = true; |
| 441 | break; |
| 442 | } |
| 443 | rtp += kOneByteExtensionHeaderLen + length; |
| 444 | // Counting padding bytes. |
| 445 | while ((rtp < extension_end) && (*rtp == 0)) { |
| 446 | ++rtp; |
| 447 | } |
| 448 | } |
| 449 | } |
| 450 | return found; |
| 451 | } |
| 452 | |
| 453 | bool ApplyPacketOptions(uint8_t* data, |
| 454 | size_t length, |
| 455 | const rtc::PacketTimeUpdateParams& packet_time_params, |
| 456 | uint64_t time_us) { |
| 457 | RTC_DCHECK(data); |
| 458 | RTC_DCHECK(length); |
| 459 | |
| 460 | // if there is no valid |rtp_sendtime_extension_id| and |srtp_auth_key| in |
| 461 | // PacketOptions, nothing to be updated in this packet. |
| 462 | if (packet_time_params.rtp_sendtime_extension_id == -1 && |
| 463 | packet_time_params.srtp_auth_key.empty()) { |
| 464 | return true; |
| 465 | } |
| 466 | |
| 467 | // If there is a srtp auth key present then the packet must be an RTP packet. |
| 468 | // RTP packet may have been wrapped in a TURN Channel Data or TURN send |
| 469 | // indication. |
| 470 | size_t rtp_start_pos; |
| 471 | size_t rtp_length; |
| 472 | if (!UnwrapTurnPacket(data, length, &rtp_start_pos, &rtp_length)) { |
| 473 | RTC_NOTREACHED(); |
| 474 | return false; |
| 475 | } |
| 476 | |
| 477 | // Making sure we have a valid RTP packet at the end. |
| 478 | if (!IsRtpPacket(data + rtp_start_pos, rtp_length) || |
| 479 | !ValidateRtpHeader(data + rtp_start_pos, rtp_length, nullptr)) { |
| 480 | RTC_NOTREACHED(); |
| 481 | return false; |
| 482 | } |
| 483 | |
| 484 | uint8_t* start = data + rtp_start_pos; |
| 485 | // If packet option has non default value (-1) for sendtime extension id, |
| 486 | // then we should parse the rtp packet to update the timestamp. Otherwise |
| 487 | // just calculate HMAC and update packet with it. |
| 488 | if (packet_time_params.rtp_sendtime_extension_id != -1) { |
| 489 | UpdateRtpAbsSendTimeExtension(start, rtp_length, |
| 490 | packet_time_params.rtp_sendtime_extension_id, |
| 491 | time_us); |
| 492 | } |
| 493 | |
| 494 | UpdateRtpAuthTag(start, rtp_length, packet_time_params); |
| 495 | return true; |
| 496 | } |
| 497 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 498 | } // namespace cricket |