zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 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. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "pc/rtptransport.h" |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 12 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 13 | #include "media/base/rtputils.h" |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 14 | #include "p2p/base/p2pconstants.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "p2p/base/packettransportinterface.h" |
| 16 | #include "rtc_base/checks.h" |
| 17 | #include "rtc_base/copyonwritebuffer.h" |
| 18 | #include "rtc_base/trace_event.h" |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 19 | |
| 20 | namespace webrtc { |
| 21 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 22 | void RtpTransport::SetRtcpMuxEnabled(bool enable) { |
| 23 | rtcp_mux_enabled_ = enable; |
| 24 | MaybeSignalReadyToSend(); |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 25 | } |
| 26 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 27 | void RtpTransport::SetRtpPacketTransport( |
| 28 | rtc::PacketTransportInternal* new_packet_transport) { |
| 29 | if (new_packet_transport == rtp_packet_transport_) { |
| 30 | return; |
| 31 | } |
| 32 | if (rtp_packet_transport_) { |
| 33 | rtp_packet_transport_->SignalReadyToSend.disconnect(this); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 34 | rtp_packet_transport_->SignalReadPacket.disconnect(this); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 35 | rtp_packet_transport_->SignalNetworkRouteChanged.disconnect(this); |
| 36 | // Reset the network route of the old transport. |
| 37 | SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 38 | } |
| 39 | if (new_packet_transport) { |
| 40 | new_packet_transport->SignalReadyToSend.connect( |
| 41 | this, &RtpTransport::OnReadyToSend); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 42 | new_packet_transport->SignalReadPacket.connect(this, |
| 43 | &RtpTransport::OnReadPacket); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 44 | new_packet_transport->SignalNetworkRouteChanged.connect( |
| 45 | this, &RtpTransport::OnNetworkRouteChange); |
| 46 | // Set the network route for the new transport. |
| 47 | SignalNetworkRouteChanged(new_packet_transport->network_route()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 48 | } |
Zhi Huang | 8c316c1 | 2017-11-13 21:13:45 +0000 | [diff] [blame] | 49 | |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 50 | rtp_packet_transport_ = new_packet_transport; |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 51 | // Assumes the transport is ready to send if it is writable. If we are wrong, |
| 52 | // ready to send will be updated the next time we try to send. |
| 53 | SetReadyToSend(false, |
| 54 | rtp_packet_transport_ && rtp_packet_transport_->writable()); |
| 55 | } |
| 56 | |
| 57 | void RtpTransport::SetRtcpPacketTransport( |
| 58 | rtc::PacketTransportInternal* new_packet_transport) { |
| 59 | if (new_packet_transport == rtcp_packet_transport_) { |
| 60 | return; |
| 61 | } |
| 62 | if (rtcp_packet_transport_) { |
| 63 | rtcp_packet_transport_->SignalReadyToSend.disconnect(this); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 64 | rtcp_packet_transport_->SignalReadPacket.disconnect(this); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 65 | rtcp_packet_transport_->SignalNetworkRouteChanged.disconnect(this); |
| 66 | // Reset the network route of the old transport. |
| 67 | SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 68 | } |
| 69 | if (new_packet_transport) { |
| 70 | new_packet_transport->SignalReadyToSend.connect( |
| 71 | this, &RtpTransport::OnReadyToSend); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 72 | new_packet_transport->SignalReadPacket.connect(this, |
| 73 | &RtpTransport::OnReadPacket); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 74 | new_packet_transport->SignalNetworkRouteChanged.connect( |
| 75 | this, &RtpTransport::OnNetworkRouteChange); |
| 76 | // Set the network route for the new transport. |
| 77 | SignalNetworkRouteChanged(new_packet_transport->network_route()); |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 78 | } |
| 79 | rtcp_packet_transport_ = new_packet_transport; |
| 80 | |
| 81 | // Assumes the transport is ready to send if it is writable. If we are wrong, |
| 82 | // ready to send will be updated the next time we try to send. |
| 83 | SetReadyToSend(true, |
| 84 | rtcp_packet_transport_ && rtcp_packet_transport_->writable()); |
| 85 | } |
| 86 | |
| 87 | bool RtpTransport::IsWritable(bool rtcp) const { |
| 88 | rtc::PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_ |
| 89 | ? rtcp_packet_transport_ |
| 90 | : rtp_packet_transport_; |
| 91 | return transport && transport->writable(); |
| 92 | } |
| 93 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 94 | bool RtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet, |
| 95 | const rtc::PacketOptions& options, |
| 96 | int flags) { |
| 97 | return SendPacket(false, packet, options, flags); |
| 98 | } |
| 99 | |
| 100 | bool RtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet, |
| 101 | const rtc::PacketOptions& options, |
| 102 | int flags) { |
| 103 | return SendPacket(true, packet, options, flags); |
| 104 | } |
| 105 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 106 | bool RtpTransport::SendPacket(bool rtcp, |
zstein | 398c3fd | 2017-07-19 13:38:02 -0700 | [diff] [blame] | 107 | rtc::CopyOnWriteBuffer* packet, |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 108 | const rtc::PacketOptions& options, |
| 109 | int flags) { |
| 110 | rtc::PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_ |
| 111 | ? rtcp_packet_transport_ |
| 112 | : rtp_packet_transport_; |
| 113 | int ret = transport->SendPacket(packet->data<char>(), packet->size(), options, |
| 114 | flags); |
| 115 | if (ret != static_cast<int>(packet->size())) { |
| 116 | if (transport->GetError() == ENOTCONN) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 117 | RTC_LOG(LS_WARNING) << "Got ENOTCONN from transport."; |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 118 | SetReadyToSend(rtcp, false); |
| 119 | } |
| 120 | return false; |
| 121 | } |
| 122 | return true; |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 123 | } |
| 124 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 125 | bool RtpTransport::HandlesPacket(const uint8_t* data, size_t len) { |
| 126 | return bundle_filter_.DemuxPacket(data, len); |
| 127 | } |
| 128 | |
| 129 | bool RtpTransport::HandlesPayloadType(int payload_type) const { |
| 130 | return bundle_filter_.FindPayloadType(payload_type); |
| 131 | } |
| 132 | |
| 133 | void RtpTransport::AddHandledPayloadType(int payload_type) { |
| 134 | bundle_filter_.AddPayloadType(payload_type); |
| 135 | } |
| 136 | |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 137 | PacketTransportInterface* RtpTransport::GetRtpPacketTransport() const { |
| 138 | return rtp_packet_transport_; |
| 139 | } |
| 140 | |
| 141 | PacketTransportInterface* RtpTransport::GetRtcpPacketTransport() const { |
| 142 | return rtcp_packet_transport_; |
| 143 | } |
| 144 | |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 145 | RTCError RtpTransport::SetParameters(const RtpTransportParameters& parameters) { |
| 146 | if (parameters_.rtcp.mux && !parameters.rtcp.mux) { |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 147 | LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, |
| 148 | "Disabling RTCP muxing is not allowed."); |
| 149 | } |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 150 | if (parameters.keepalive != parameters_.keepalive) { |
| 151 | // TODO(sprang): Wire up support for keep-alive (only ORTC support for now). |
| 152 | LOG_AND_RETURN_ERROR( |
| 153 | RTCErrorType::INVALID_MODIFICATION, |
| 154 | "RTP keep-alive parameters not supported by this channel."); |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 155 | } |
| 156 | |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 157 | RtpTransportParameters new_parameters = parameters; |
| 158 | |
| 159 | if (new_parameters.rtcp.cname.empty()) { |
| 160 | new_parameters.rtcp.cname = parameters_.rtcp.cname; |
| 161 | } |
| 162 | |
| 163 | parameters_ = new_parameters; |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 164 | return RTCError::OK(); |
| 165 | } |
| 166 | |
sprang | db2a9fc | 2017-08-09 06:42:32 -0700 | [diff] [blame] | 167 | RtpTransportParameters RtpTransport::GetParameters() const { |
| 168 | return parameters_; |
zstein | d9ce764 | 2017-04-10 16:17:57 -0700 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | RtpTransportAdapter* RtpTransport::GetInternal() { |
| 172 | return nullptr; |
| 173 | } |
| 174 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 175 | void RtpTransport::OnReadyToSend(rtc::PacketTransportInternal* transport) { |
| 176 | SetReadyToSend(transport == rtcp_packet_transport_, true); |
| 177 | } |
| 178 | |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 179 | void RtpTransport::OnNetworkRouteChange( |
| 180 | rtc::Optional<rtc::NetworkRoute> network_route) { |
| 181 | SignalNetworkRouteChanged(network_route); |
| 182 | } |
| 183 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 184 | void RtpTransport::SetReadyToSend(bool rtcp, bool ready) { |
| 185 | if (rtcp) { |
| 186 | rtcp_ready_to_send_ = ready; |
| 187 | } else { |
| 188 | rtp_ready_to_send_ = ready; |
| 189 | } |
| 190 | |
| 191 | MaybeSignalReadyToSend(); |
| 192 | } |
| 193 | |
| 194 | void RtpTransport::MaybeSignalReadyToSend() { |
| 195 | bool ready_to_send = |
| 196 | rtp_ready_to_send_ && (rtcp_ready_to_send_ || rtcp_mux_enabled_); |
| 197 | if (ready_to_send != ready_to_send_) { |
| 198 | ready_to_send_ = ready_to_send; |
| 199 | SignalReadyToSend(ready_to_send); |
| 200 | } |
| 201 | } |
| 202 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 203 | // Check the RTP payload type. If 63 < payload type < 96, it's RTCP. |
| 204 | // For additional details, see http://tools.ietf.org/html/rfc5761. |
| 205 | bool IsRtcp(const char* data, int len) { |
| 206 | if (len < 2) { |
| 207 | return false; |
| 208 | } |
| 209 | char pt = data[1] & 0x7F; |
| 210 | return (63 < pt) && (pt < 96); |
| 211 | } |
| 212 | |
| 213 | void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport, |
| 214 | const char* data, |
| 215 | size_t len, |
| 216 | const rtc::PacketTime& packet_time, |
| 217 | int flags) { |
| 218 | TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket"); |
| 219 | |
| 220 | // When using RTCP multiplexing we might get RTCP packets on the RTP |
| 221 | // transport. We check the RTP payload type to determine if it is RTCP. |
| 222 | bool rtcp = transport == rtcp_packet_transport() || |
| 223 | IsRtcp(data, static_cast<int>(len)); |
| 224 | rtc::CopyOnWriteBuffer packet(data, len); |
| 225 | |
| 226 | if (!WantsPacket(rtcp, &packet)) { |
| 227 | return; |
| 228 | } |
| 229 | |
| 230 | // This mutates |packet| if it is protected. |
zstein | 634977b | 2017-07-14 12:30:04 -0700 | [diff] [blame] | 231 | SignalPacketReceived(rtcp, &packet, packet_time); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | bool RtpTransport::WantsPacket(bool rtcp, |
| 235 | const rtc::CopyOnWriteBuffer* packet) { |
| 236 | // Protect ourselves against crazy data. |
| 237 | if (!packet || !cricket::IsValidRtpRtcpPacketSize(rtcp, packet->size())) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 238 | RTC_LOG(LS_ERROR) << "Dropping incoming " |
| 239 | << cricket::RtpRtcpStringLiteral(rtcp) |
| 240 | << " packet: wrong size=" << packet->size(); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 241 | return false; |
| 242 | } |
| 243 | if (rtcp) { |
| 244 | // Permit all (seemingly valid) RTCP packets. |
| 245 | return true; |
| 246 | } |
| 247 | // Check whether we handle this payload. |
| 248 | return HandlesPacket(packet->data(), packet->size()); |
| 249 | } |
| 250 | |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 251 | } // namespace webrtc |