| /* |
| * Copyright 2017 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. |
| */ |
| |
| #include "pc/rtptransport.h" |
| |
| #include "media/base/rtputils.h" |
| #include "p2p/base/p2pconstants.h" |
| #include "p2p/base/packettransportinterface.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/copyonwritebuffer.h" |
| #include "rtc_base/trace_event.h" |
| |
| namespace webrtc { |
| |
| void RtpTransport::SetRtcpMuxEnabled(bool enable) { |
| rtcp_mux_enabled_ = enable; |
| MaybeSignalReadyToSend(); |
| } |
| |
| void RtpTransport::SetRtpPacketTransport( |
| rtc::PacketTransportInternal* new_packet_transport) { |
| if (new_packet_transport == rtp_packet_transport_) { |
| return; |
| } |
| if (rtp_packet_transport_) { |
| rtp_packet_transport_->SignalReadyToSend.disconnect(this); |
| rtp_packet_transport_->SignalReadPacket.disconnect(this); |
| rtp_packet_transport_->SignalNetworkRouteChanged.disconnect(this); |
| // Reset the network route of the old transport. |
| SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>()); |
| } |
| if (new_packet_transport) { |
| new_packet_transport->SignalReadyToSend.connect( |
| this, &RtpTransport::OnReadyToSend); |
| new_packet_transport->SignalReadPacket.connect(this, |
| &RtpTransport::OnReadPacket); |
| new_packet_transport->SignalNetworkRouteChanged.connect( |
| this, &RtpTransport::OnNetworkRouteChange); |
| // Set the network route for the new transport. |
| SignalNetworkRouteChanged(new_packet_transport->network_route()); |
| } |
| |
| rtp_packet_transport_ = new_packet_transport; |
| // Assumes the transport is ready to send if it is writable. If we are wrong, |
| // ready to send will be updated the next time we try to send. |
| SetReadyToSend(false, |
| rtp_packet_transport_ && rtp_packet_transport_->writable()); |
| } |
| |
| void RtpTransport::SetRtcpPacketTransport( |
| rtc::PacketTransportInternal* new_packet_transport) { |
| if (new_packet_transport == rtcp_packet_transport_) { |
| return; |
| } |
| if (rtcp_packet_transport_) { |
| rtcp_packet_transport_->SignalReadyToSend.disconnect(this); |
| rtcp_packet_transport_->SignalReadPacket.disconnect(this); |
| rtcp_packet_transport_->SignalNetworkRouteChanged.disconnect(this); |
| // Reset the network route of the old transport. |
| SignalNetworkRouteChanged(rtc::Optional<rtc::NetworkRoute>()); |
| } |
| if (new_packet_transport) { |
| new_packet_transport->SignalReadyToSend.connect( |
| this, &RtpTransport::OnReadyToSend); |
| new_packet_transport->SignalReadPacket.connect(this, |
| &RtpTransport::OnReadPacket); |
| new_packet_transport->SignalNetworkRouteChanged.connect( |
| this, &RtpTransport::OnNetworkRouteChange); |
| // Set the network route for the new transport. |
| SignalNetworkRouteChanged(new_packet_transport->network_route()); |
| } |
| rtcp_packet_transport_ = new_packet_transport; |
| |
| // Assumes the transport is ready to send if it is writable. If we are wrong, |
| // ready to send will be updated the next time we try to send. |
| SetReadyToSend(true, |
| rtcp_packet_transport_ && rtcp_packet_transport_->writable()); |
| } |
| |
| bool RtpTransport::IsWritable(bool rtcp) const { |
| rtc::PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_ |
| ? rtcp_packet_transport_ |
| : rtp_packet_transport_; |
| return transport && transport->writable(); |
| } |
| |
| bool RtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet, |
| const rtc::PacketOptions& options, |
| int flags) { |
| return SendPacket(false, packet, options, flags); |
| } |
| |
| bool RtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet, |
| const rtc::PacketOptions& options, |
| int flags) { |
| return SendPacket(true, packet, options, flags); |
| } |
| |
| bool RtpTransport::SendPacket(bool rtcp, |
| rtc::CopyOnWriteBuffer* packet, |
| const rtc::PacketOptions& options, |
| int flags) { |
| rtc::PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_ |
| ? rtcp_packet_transport_ |
| : rtp_packet_transport_; |
| int ret = transport->SendPacket(packet->data<char>(), packet->size(), options, |
| flags); |
| if (ret != static_cast<int>(packet->size())) { |
| if (transport->GetError() == ENOTCONN) { |
| RTC_LOG(LS_WARNING) << "Got ENOTCONN from transport."; |
| SetReadyToSend(rtcp, false); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| bool RtpTransport::HandlesPacket(const uint8_t* data, size_t len) { |
| return bundle_filter_.DemuxPacket(data, len); |
| } |
| |
| bool RtpTransport::HandlesPayloadType(int payload_type) const { |
| return bundle_filter_.FindPayloadType(payload_type); |
| } |
| |
| void RtpTransport::AddHandledPayloadType(int payload_type) { |
| bundle_filter_.AddPayloadType(payload_type); |
| } |
| |
| PacketTransportInterface* RtpTransport::GetRtpPacketTransport() const { |
| return rtp_packet_transport_; |
| } |
| |
| PacketTransportInterface* RtpTransport::GetRtcpPacketTransport() const { |
| return rtcp_packet_transport_; |
| } |
| |
| RTCError RtpTransport::SetParameters(const RtpTransportParameters& parameters) { |
| if (parameters_.rtcp.mux && !parameters.rtcp.mux) { |
| LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE, |
| "Disabling RTCP muxing is not allowed."); |
| } |
| if (parameters.keepalive != parameters_.keepalive) { |
| // TODO(sprang): Wire up support for keep-alive (only ORTC support for now). |
| LOG_AND_RETURN_ERROR( |
| RTCErrorType::INVALID_MODIFICATION, |
| "RTP keep-alive parameters not supported by this channel."); |
| } |
| |
| RtpTransportParameters new_parameters = parameters; |
| |
| if (new_parameters.rtcp.cname.empty()) { |
| new_parameters.rtcp.cname = parameters_.rtcp.cname; |
| } |
| |
| parameters_ = new_parameters; |
| return RTCError::OK(); |
| } |
| |
| RtpTransportParameters RtpTransport::GetParameters() const { |
| return parameters_; |
| } |
| |
| RtpTransportAdapter* RtpTransport::GetInternal() { |
| return nullptr; |
| } |
| |
| void RtpTransport::OnReadyToSend(rtc::PacketTransportInternal* transport) { |
| SetReadyToSend(transport == rtcp_packet_transport_, true); |
| } |
| |
| void RtpTransport::OnNetworkRouteChange( |
| rtc::Optional<rtc::NetworkRoute> network_route) { |
| SignalNetworkRouteChanged(network_route); |
| } |
| |
| void RtpTransport::SetReadyToSend(bool rtcp, bool ready) { |
| if (rtcp) { |
| rtcp_ready_to_send_ = ready; |
| } else { |
| rtp_ready_to_send_ = ready; |
| } |
| |
| MaybeSignalReadyToSend(); |
| } |
| |
| void RtpTransport::MaybeSignalReadyToSend() { |
| bool ready_to_send = |
| rtp_ready_to_send_ && (rtcp_ready_to_send_ || rtcp_mux_enabled_); |
| if (ready_to_send != ready_to_send_) { |
| ready_to_send_ = ready_to_send; |
| SignalReadyToSend(ready_to_send); |
| } |
| } |
| |
| // Check the RTP payload type. If 63 < payload type < 96, it's RTCP. |
| // For additional details, see http://tools.ietf.org/html/rfc5761. |
| bool IsRtcp(const char* data, int len) { |
| if (len < 2) { |
| return false; |
| } |
| char pt = data[1] & 0x7F; |
| return (63 < pt) && (pt < 96); |
| } |
| |
| void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport, |
| const char* data, |
| size_t len, |
| const rtc::PacketTime& packet_time, |
| int flags) { |
| TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket"); |
| |
| // When using RTCP multiplexing we might get RTCP packets on the RTP |
| // transport. We check the RTP payload type to determine if it is RTCP. |
| bool rtcp = transport == rtcp_packet_transport() || |
| IsRtcp(data, static_cast<int>(len)); |
| rtc::CopyOnWriteBuffer packet(data, len); |
| |
| if (!WantsPacket(rtcp, &packet)) { |
| return; |
| } |
| |
| // This mutates |packet| if it is protected. |
| SignalPacketReceived(rtcp, &packet, packet_time); |
| } |
| |
| bool RtpTransport::WantsPacket(bool rtcp, |
| const rtc::CopyOnWriteBuffer* packet) { |
| // Protect ourselves against crazy data. |
| if (!packet || !cricket::IsValidRtpRtcpPacketSize(rtcp, packet->size())) { |
| RTC_LOG(LS_ERROR) << "Dropping incoming " |
| << cricket::RtpRtcpStringLiteral(rtcp) |
| << " packet: wrong size=" << packet->size(); |
| return false; |
| } |
| if (rtcp) { |
| // Permit all (seemingly valid) RTCP packets. |
| return true; |
| } |
| // Check whether we handle this payload. |
| return HandlesPacket(packet->data(), packet->size()); |
| } |
| |
| } // namespace webrtc |
