1 /* 2 * libjingle 3 * Copyright 2004 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "talk/session/media/channel.h" 29 30 #include "talk/media/base/constants.h" 31 #include "talk/media/base/rtputils.h" 32 #include "talk/p2p/base/transportchannel.h" 33 #include "talk/session/media/channelmanager.h" 34 #include "talk/session/media/mediamessages.h" 35 #include "talk/session/media/typingmonitor.h" 36 #include "webrtc/base/bind.h" 37 #include "webrtc/base/buffer.h" 38 #include "webrtc/base/byteorder.h" 39 #include "webrtc/base/common.h" 40 #include "webrtc/base/dscp.h" 41 #include "webrtc/base/logging.h" 42 43 namespace cricket { 44 45 using rtc::Bind; 46 47 enum { 48 MSG_EARLYMEDIATIMEOUT = 1, 49 MSG_SCREENCASTWINDOWEVENT, 50 MSG_RTPPACKET, 51 MSG_RTCPPACKET, 52 MSG_CHANNEL_ERROR, 53 MSG_READYTOSENDDATA, 54 MSG_DATARECEIVED, 55 MSG_FIRSTPACKETRECEIVED, 56 MSG_STREAMCLOSEDREMOTELY, 57 }; 58 59 // Value specified in RFC 5764. 60 static const char kDtlsSrtpExporterLabel[] = "EXTRACTOR-dtls_srtp"; 61 62 static const int kAgcMinus10db = -10; 63 64 static void SetSessionError(BaseSession* session, BaseSession::Error error, 65 const std::string& error_desc) { 66 session->SetError(error, error_desc); 67 } 68 69 static void SafeSetError(const std::string& message, std::string* error_desc) { 70 if (error_desc) { 71 *error_desc = message; 72 } 73 } 74 75 struct PacketMessageData : public rtc::MessageData { 76 rtc::Buffer packet; 77 rtc::DiffServCodePoint dscp; 78 }; 79 80 struct ScreencastEventMessageData : public rtc::MessageData { 81 ScreencastEventMessageData(uint32 s, rtc::WindowEvent we) 82 : ssrc(s), 83 event(we) { 84 } 85 uint32 ssrc; 86 rtc::WindowEvent event; 87 }; 88 89 struct VoiceChannelErrorMessageData : public rtc::MessageData { 90 VoiceChannelErrorMessageData(uint32 in_ssrc, 91 VoiceMediaChannel::Error in_error) 92 : ssrc(in_ssrc), 93 error(in_error) { 94 } 95 uint32 ssrc; 96 VoiceMediaChannel::Error error; 97 }; 98 99 struct VideoChannelErrorMessageData : public rtc::MessageData { 100 VideoChannelErrorMessageData(uint32 in_ssrc, 101 VideoMediaChannel::Error in_error) 102 : ssrc(in_ssrc), 103 error(in_error) { 104 } 105 uint32 ssrc; 106 VideoMediaChannel::Error error; 107 }; 108 109 struct DataChannelErrorMessageData : public rtc::MessageData { 110 DataChannelErrorMessageData(uint32 in_ssrc, 111 DataMediaChannel::Error in_error) 112 : ssrc(in_ssrc), 113 error(in_error) {} 114 uint32 ssrc; 115 DataMediaChannel::Error error; 116 }; 117 118 119 struct VideoChannel::ScreencastDetailsData { 120 explicit ScreencastDetailsData(uint32 s) 121 : ssrc(s), fps(0), screencast_max_pixels(0) { 122 } 123 uint32 ssrc; 124 int fps; 125 int screencast_max_pixels; 126 }; 127 128 static const char* PacketType(bool rtcp) { 129 return (!rtcp) ? "RTP" : "RTCP"; 130 } 131 132 static bool ValidPacket(bool rtcp, const rtc::Buffer* packet) { 133 // Check the packet size. We could check the header too if needed. 134 return (packet && 135 packet->length() >= (!rtcp ? kMinRtpPacketLen : kMinRtcpPacketLen) && 136 packet->length() <= kMaxRtpPacketLen); 137 } 138 139 static bool IsReceiveContentDirection(MediaContentDirection direction) { 140 return direction == MD_SENDRECV || direction == MD_RECVONLY; 141 } 142 143 static bool IsSendContentDirection(MediaContentDirection direction) { 144 return direction == MD_SENDRECV || direction == MD_SENDONLY; 145 } 146 147 static const MediaContentDescription* GetContentDescription( 148 const ContentInfo* cinfo) { 149 if (cinfo == NULL) 150 return NULL; 151 return static_cast<const MediaContentDescription*>(cinfo->description); 152 } 153 154 BaseChannel::BaseChannel(rtc::Thread* thread, 155 MediaEngineInterface* media_engine, 156 MediaChannel* media_channel, BaseSession* session, 157 const std::string& content_name, bool rtcp) 158 : worker_thread_(thread), 159 media_engine_(media_engine), 160 session_(session), 161 media_channel_(media_channel), 162 content_name_(content_name), 163 rtcp_(rtcp), 164 transport_channel_(NULL), 165 rtcp_transport_channel_(NULL), 166 enabled_(false), 167 writable_(false), 168 rtp_ready_to_send_(false), 169 rtcp_ready_to_send_(false), 170 was_ever_writable_(false), 171 local_content_direction_(MD_INACTIVE), 172 remote_content_direction_(MD_INACTIVE), 173 has_received_packet_(false), 174 dtls_keyed_(false), 175 secure_required_(false), 176 rtp_abs_sendtime_extn_id_(-1) { 177 ASSERT(worker_thread_ == rtc::Thread::Current()); 178 LOG(LS_INFO) << "Created channel for " << content_name; 179 } 180 181 BaseChannel::~BaseChannel() { 182 ASSERT(worker_thread_ == rtc::Thread::Current()); 183 Deinit(); 184 StopConnectionMonitor(); 185 FlushRtcpMessages(); // Send any outstanding RTCP packets. 186 worker_thread_->Clear(this); // eats any outstanding messages or packets 187 // We must destroy the media channel before the transport channel, otherwise 188 // the media channel may try to send on the dead transport channel. NULLing 189 // is not an effective strategy since the sends will come on another thread. 190 delete media_channel_; 191 set_rtcp_transport_channel(NULL); 192 if (transport_channel_ != NULL) 193 session_->DestroyChannel(content_name_, transport_channel_->component()); 194 LOG(LS_INFO) << "Destroyed channel"; 195 } 196 197 bool BaseChannel::Init(TransportChannel* transport_channel, 198 TransportChannel* rtcp_transport_channel) { 199 if (transport_channel == NULL) { 200 return false; 201 } 202 if (rtcp() && rtcp_transport_channel == NULL) { 203 return false; 204 } 205 transport_channel_ = transport_channel; 206 207 if (!SetDtlsSrtpCiphers(transport_channel_, false)) { 208 return false; 209 } 210 211 transport_channel_->SignalWritableState.connect( 212 this, &BaseChannel::OnWritableState); 213 transport_channel_->SignalReadPacket.connect( 214 this, &BaseChannel::OnChannelRead); 215 transport_channel_->SignalReadyToSend.connect( 216 this, &BaseChannel::OnReadyToSend); 217 218 session_->SignalNewLocalDescription.connect( 219 this, &BaseChannel::OnNewLocalDescription); 220 session_->SignalNewRemoteDescription.connect( 221 this, &BaseChannel::OnNewRemoteDescription); 222 223 set_rtcp_transport_channel(rtcp_transport_channel); 224 // Both RTP and RTCP channels are set, we can call SetInterface on 225 // media channel and it can set network options. 226 media_channel_->SetInterface(this); 227 return true; 228 } 229 230 void BaseChannel::Deinit() { 231 media_channel_->SetInterface(NULL); 232 } 233 234 bool BaseChannel::Enable(bool enable) { 235 worker_thread_->Invoke<void>(Bind( 236 enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w, 237 this)); 238 return true; 239 } 240 241 bool BaseChannel::MuteStream(uint32 ssrc, bool mute) { 242 return InvokeOnWorker(Bind(&BaseChannel::MuteStream_w, this, ssrc, mute)); 243 } 244 245 bool BaseChannel::IsStreamMuted(uint32 ssrc) { 246 return InvokeOnWorker(Bind(&BaseChannel::IsStreamMuted_w, this, ssrc)); 247 } 248 249 bool BaseChannel::AddRecvStream(const StreamParams& sp) { 250 return InvokeOnWorker(Bind(&BaseChannel::AddRecvStream_w, this, sp)); 251 } 252 253 bool BaseChannel::RemoveRecvStream(uint32 ssrc) { 254 return InvokeOnWorker(Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc)); 255 } 256 257 bool BaseChannel::AddSendStream(const StreamParams& sp) { 258 return InvokeOnWorker( 259 Bind(&MediaChannel::AddSendStream, media_channel(), sp)); 260 } 261 262 bool BaseChannel::RemoveSendStream(uint32 ssrc) { 263 return InvokeOnWorker( 264 Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc)); 265 } 266 267 bool BaseChannel::SetLocalContent(const MediaContentDescription* content, 268 ContentAction action, 269 std::string* error_desc) { 270 return InvokeOnWorker(Bind(&BaseChannel::SetLocalContent_w, 271 this, content, action, error_desc)); 272 } 273 274 bool BaseChannel::SetRemoteContent(const MediaContentDescription* content, 275 ContentAction action, 276 std::string* error_desc) { 277 return InvokeOnWorker(Bind(&BaseChannel::SetRemoteContent_w, 278 this, content, action, error_desc)); 279 } 280 281 void BaseChannel::StartConnectionMonitor(int cms) { 282 socket_monitor_.reset(new SocketMonitor(transport_channel_, 283 worker_thread(), 284 rtc::Thread::Current())); 285 socket_monitor_->SignalUpdate.connect( 286 this, &BaseChannel::OnConnectionMonitorUpdate); 287 socket_monitor_->Start(cms); 288 } 289 290 void BaseChannel::StopConnectionMonitor() { 291 if (socket_monitor_) { 292 socket_monitor_->Stop(); 293 socket_monitor_.reset(); 294 } 295 } 296 297 void BaseChannel::set_rtcp_transport_channel(TransportChannel* channel) { 298 if (rtcp_transport_channel_ != channel) { 299 if (rtcp_transport_channel_) { 300 session_->DestroyChannel( 301 content_name_, rtcp_transport_channel_->component()); 302 } 303 rtcp_transport_channel_ = channel; 304 if (rtcp_transport_channel_) { 305 // TODO(juberti): Propagate this error code 306 VERIFY(SetDtlsSrtpCiphers(rtcp_transport_channel_, true)); 307 rtcp_transport_channel_->SignalWritableState.connect( 308 this, &BaseChannel::OnWritableState); 309 rtcp_transport_channel_->SignalReadPacket.connect( 310 this, &BaseChannel::OnChannelRead); 311 rtcp_transport_channel_->SignalReadyToSend.connect( 312 this, &BaseChannel::OnReadyToSend); 313 } 314 } 315 } 316 317 bool BaseChannel::IsReadyToReceive() const { 318 // Receive data if we are enabled and have local content, 319 return enabled() && IsReceiveContentDirection(local_content_direction_); 320 } 321 322 bool BaseChannel::IsReadyToSend() const { 323 // Send outgoing data if we are enabled, have local and remote content, 324 // and we have had some form of connectivity. 325 return enabled() && 326 IsReceiveContentDirection(remote_content_direction_) && 327 IsSendContentDirection(local_content_direction_) && 328 was_ever_writable(); 329 } 330 331 bool BaseChannel::SendPacket(rtc::Buffer* packet, 332 rtc::DiffServCodePoint dscp) { 333 return SendPacket(false, packet, dscp); 334 } 335 336 bool BaseChannel::SendRtcp(rtc::Buffer* packet, 337 rtc::DiffServCodePoint dscp) { 338 return SendPacket(true, packet, dscp); 339 } 340 341 int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt, 342 int value) { 343 TransportChannel* channel = NULL; 344 switch (type) { 345 case ST_RTP: 346 channel = transport_channel_; 347 break; 348 case ST_RTCP: 349 channel = rtcp_transport_channel_; 350 break; 351 } 352 return channel ? channel->SetOption(opt, value) : -1; 353 } 354 355 void BaseChannel::OnWritableState(TransportChannel* channel) { 356 ASSERT(channel == transport_channel_ || channel == rtcp_transport_channel_); 357 if (transport_channel_->writable() 358 && (!rtcp_transport_channel_ || rtcp_transport_channel_->writable())) { 359 ChannelWritable_w(); 360 } else { 361 ChannelNotWritable_w(); 362 } 363 } 364 365 void BaseChannel::OnChannelRead(TransportChannel* channel, 366 const char* data, size_t len, 367 const rtc::PacketTime& packet_time, 368 int flags) { 369 // OnChannelRead gets called from P2PSocket; now pass data to MediaEngine 370 ASSERT(worker_thread_ == rtc::Thread::Current()); 371 372 // When using RTCP multiplexing we might get RTCP packets on the RTP 373 // transport. We feed RTP traffic into the demuxer to determine if it is RTCP. 374 bool rtcp = PacketIsRtcp(channel, data, len); 375 rtc::Buffer packet(data, len); 376 HandlePacket(rtcp, &packet, packet_time); 377 } 378 379 void BaseChannel::OnReadyToSend(TransportChannel* channel) { 380 SetReadyToSend(channel, true); 381 } 382 383 void BaseChannel::SetReadyToSend(TransportChannel* channel, bool ready) { 384 ASSERT(channel == transport_channel_ || channel == rtcp_transport_channel_); 385 if (channel == transport_channel_) { 386 rtp_ready_to_send_ = ready; 387 } 388 if (channel == rtcp_transport_channel_) { 389 rtcp_ready_to_send_ = ready; 390 } 391 392 if (!ready) { 393 // Notify the MediaChannel when either rtp or rtcp channel can't send. 394 media_channel_->OnReadyToSend(false); 395 } else if (rtp_ready_to_send_ && 396 // In the case of rtcp mux |rtcp_transport_channel_| will be null. 397 (rtcp_ready_to_send_ || !rtcp_transport_channel_)) { 398 // Notify the MediaChannel when both rtp and rtcp channel can send. 399 media_channel_->OnReadyToSend(true); 400 } 401 } 402 403 bool BaseChannel::PacketIsRtcp(const TransportChannel* channel, 404 const char* data, size_t len) { 405 return (channel == rtcp_transport_channel_ || 406 rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len))); 407 } 408 409 bool BaseChannel::SendPacket(bool rtcp, rtc::Buffer* packet, 410 rtc::DiffServCodePoint dscp) { 411 // SendPacket gets called from MediaEngine, typically on an encoder thread. 412 // If the thread is not our worker thread, we will post to our worker 413 // so that the real work happens on our worker. This avoids us having to 414 // synchronize access to all the pieces of the send path, including 415 // SRTP and the inner workings of the transport channels. 416 // The only downside is that we can't return a proper failure code if 417 // needed. Since UDP is unreliable anyway, this should be a non-issue. 418 if (rtc::Thread::Current() != worker_thread_) { 419 // Avoid a copy by transferring the ownership of the packet data. 420 int message_id = (!rtcp) ? MSG_RTPPACKET : MSG_RTCPPACKET; 421 PacketMessageData* data = new PacketMessageData; 422 packet->TransferTo(&data->packet); 423 data->dscp = dscp; 424 worker_thread_->Post(this, message_id, data); 425 return true; 426 } 427 428 // Now that we are on the correct thread, ensure we have a place to send this 429 // packet before doing anything. (We might get RTCP packets that we don't 430 // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP 431 // transport. 432 TransportChannel* channel = (!rtcp || rtcp_mux_filter_.IsActive()) ? 433 transport_channel_ : rtcp_transport_channel_; 434 if (!channel || !channel->writable()) { 435 return false; 436 } 437 438 // Protect ourselves against crazy data. 439 if (!ValidPacket(rtcp, packet)) { 440 LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " " 441 << PacketType(rtcp) << " packet: wrong size=" 442 << packet->length(); 443 return false; 444 } 445 446 // Signal to the media sink before protecting the packet. 447 { 448 rtc::CritScope cs(&signal_send_packet_cs_); 449 SignalSendPacketPreCrypto(packet->data(), packet->length(), rtcp); 450 } 451 452 rtc::PacketOptions options(dscp); 453 // Protect if needed. 454 if (srtp_filter_.IsActive()) { 455 bool res; 456 char* data = packet->data(); 457 int len = static_cast<int>(packet->length()); 458 if (!rtcp) { 459 // If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done 460 // inside libsrtp for a RTP packet. A external HMAC module will be writing 461 // a fake HMAC value. This is ONLY done for a RTP packet. 462 // Socket layer will update rtp sendtime extension header if present in 463 // packet with current time before updating the HMAC. 464 #if !defined(ENABLE_EXTERNAL_AUTH) 465 res = srtp_filter_.ProtectRtp( 466 data, len, static_cast<int>(packet->capacity()), &len); 467 #else 468 options.packet_time_params.rtp_sendtime_extension_id = 469 rtp_abs_sendtime_extn_id_; 470 res = srtp_filter_.ProtectRtp( 471 data, len, static_cast<int>(packet->capacity()), &len, 472 &options.packet_time_params.srtp_packet_index); 473 // If protection succeeds, let's get auth params from srtp. 474 if (res) { 475 uint8* auth_key = NULL; 476 int key_len; 477 res = srtp_filter_.GetRtpAuthParams( 478 &auth_key, &key_len, &options.packet_time_params.srtp_auth_tag_len); 479 if (res) { 480 options.packet_time_params.srtp_auth_key.resize(key_len); 481 options.packet_time_params.srtp_auth_key.assign(auth_key, 482 auth_key + key_len); 483 } 484 } 485 #endif 486 if (!res) { 487 int seq_num = -1; 488 uint32 ssrc = 0; 489 GetRtpSeqNum(data, len, &seq_num); 490 GetRtpSsrc(data, len, &ssrc); 491 LOG(LS_ERROR) << "Failed to protect " << content_name_ 492 << " RTP packet: size=" << len 493 << ", seqnum=" << seq_num << ", SSRC=" << ssrc; 494 return false; 495 } 496 } else { 497 res = srtp_filter_.ProtectRtcp(data, len, 498 static_cast<int>(packet->capacity()), 499 &len); 500 if (!res) { 501 int type = -1; 502 GetRtcpType(data, len, &type); 503 LOG(LS_ERROR) << "Failed to protect " << content_name_ 504 << " RTCP packet: size=" << len << ", type=" << type; 505 return false; 506 } 507 } 508 509 // Update the length of the packet now that we've added the auth tag. 510 packet->SetLength(len); 511 } else if (secure_required_) { 512 // This is a double check for something that supposedly can't happen. 513 LOG(LS_ERROR) << "Can't send outgoing " << PacketType(rtcp) 514 << " packet when SRTP is inactive and crypto is required"; 515 516 ASSERT(false); 517 return false; 518 } 519 520 // Signal to the media sink after protecting the packet. 521 { 522 rtc::CritScope cs(&signal_send_packet_cs_); 523 SignalSendPacketPostCrypto(packet->data(), packet->length(), rtcp); 524 } 525 526 // Bon voyage. 527 int ret = channel->SendPacket(packet->data(), packet->length(), options, 528 (secure() && secure_dtls()) ? PF_SRTP_BYPASS : 0); 529 if (ret != static_cast<int>(packet->length())) { 530 if (channel->GetError() == EWOULDBLOCK) { 531 LOG(LS_WARNING) << "Got EWOULDBLOCK from socket."; 532 SetReadyToSend(channel, false); 533 } 534 return false; 535 } 536 return true; 537 } 538 539 bool BaseChannel::WantsPacket(bool rtcp, rtc::Buffer* packet) { 540 // Protect ourselves against crazy data. 541 if (!ValidPacket(rtcp, packet)) { 542 LOG(LS_ERROR) << "Dropping incoming " << content_name_ << " " 543 << PacketType(rtcp) << " packet: wrong size=" 544 << packet->length(); 545 return false; 546 } 547 548 // Bundle filter handles both rtp and rtcp packets. 549 return bundle_filter_.DemuxPacket(packet->data(), packet->length(), rtcp); 550 } 551 552 void BaseChannel::HandlePacket(bool rtcp, rtc::Buffer* packet, 553 const rtc::PacketTime& packet_time) { 554 if (!WantsPacket(rtcp, packet)) { 555 return; 556 } 557 558 if (!has_received_packet_) { 559 has_received_packet_ = true; 560 signaling_thread()->Post(this, MSG_FIRSTPACKETRECEIVED); 561 } 562 563 // Signal to the media sink before unprotecting the packet. 564 { 565 rtc::CritScope cs(&signal_recv_packet_cs_); 566 SignalRecvPacketPostCrypto(packet->data(), packet->length(), rtcp); 567 } 568 569 // Unprotect the packet, if needed. 570 if (srtp_filter_.IsActive()) { 571 char* data = packet->data(); 572 int len = static_cast<int>(packet->length()); 573 bool res; 574 if (!rtcp) { 575 res = srtp_filter_.UnprotectRtp(data, len, &len); 576 if (!res) { 577 int seq_num = -1; 578 uint32 ssrc = 0; 579 GetRtpSeqNum(data, len, &seq_num); 580 GetRtpSsrc(data, len, &ssrc); 581 LOG(LS_ERROR) << "Failed to unprotect " << content_name_ 582 << " RTP packet: size=" << len 583 << ", seqnum=" << seq_num << ", SSRC=" << ssrc; 584 return; 585 } 586 } else { 587 res = srtp_filter_.UnprotectRtcp(data, len, &len); 588 if (!res) { 589 int type = -1; 590 GetRtcpType(data, len, &type); 591 LOG(LS_ERROR) << "Failed to unprotect " << content_name_ 592 << " RTCP packet: size=" << len << ", type=" << type; 593 return; 594 } 595 } 596 597 packet->SetLength(len); 598 } else if (secure_required_) { 599 // Our session description indicates that SRTP is required, but we got a 600 // packet before our SRTP filter is active. This means either that 601 // a) we got SRTP packets before we received the SDES keys, in which case 602 // we can't decrypt it anyway, or 603 // b) we got SRTP packets before DTLS completed on both the RTP and RTCP 604 // channels, so we haven't yet extracted keys, even if DTLS did complete 605 // on the channel that the packets are being sent on. It's really good 606 // practice to wait for both RTP and RTCP to be good to go before sending 607 // media, to prevent weird failure modes, so it's fine for us to just eat 608 // packets here. This is all sidestepped if RTCP mux is used anyway. 609 LOG(LS_WARNING) << "Can't process incoming " << PacketType(rtcp) 610 << " packet when SRTP is inactive and crypto is required"; 611 return; 612 } 613 614 // Signal to the media sink after unprotecting the packet. 615 { 616 rtc::CritScope cs(&signal_recv_packet_cs_); 617 SignalRecvPacketPreCrypto(packet->data(), packet->length(), rtcp); 618 } 619 620 // Push it down to the media channel. 621 if (!rtcp) { 622 media_channel_->OnPacketReceived(packet, packet_time); 623 } else { 624 media_channel_->OnRtcpReceived(packet, packet_time); 625 } 626 } 627 628 void BaseChannel::OnNewLocalDescription( 629 BaseSession* session, ContentAction action) { 630 const ContentInfo* content_info = 631 GetFirstContent(session->local_description()); 632 const MediaContentDescription* content_desc = 633 GetContentDescription(content_info); 634 std::string error_desc; 635 if (content_desc && content_info && !content_info->rejected && 636 !SetLocalContent(content_desc, action, &error_desc)) { 637 SetSessionError(session_, BaseSession::ERROR_CONTENT, error_desc); 638 LOG(LS_ERROR) << "Failure in SetLocalContent with action " << action; 639 } 640 } 641 642 void BaseChannel::OnNewRemoteDescription( 643 BaseSession* session, ContentAction action) { 644 const ContentInfo* content_info = 645 GetFirstContent(session->remote_description()); 646 const MediaContentDescription* content_desc = 647 GetContentDescription(content_info); 648 std::string error_desc; 649 if (content_desc && content_info && !content_info->rejected && 650 !SetRemoteContent(content_desc, action, &error_desc)) { 651 SetSessionError(session_, BaseSession::ERROR_CONTENT, error_desc); 652 LOG(LS_ERROR) << "Failure in SetRemoteContent with action " << action; 653 } 654 } 655 656 void BaseChannel::EnableMedia_w() { 657 ASSERT(worker_thread_ == rtc::Thread::Current()); 658 if (enabled_) 659 return; 660 661 LOG(LS_INFO) << "Channel enabled"; 662 enabled_ = true; 663 ChangeState(); 664 } 665 666 void BaseChannel::DisableMedia_w() { 667 ASSERT(worker_thread_ == rtc::Thread::Current()); 668 if (!enabled_) 669 return; 670 671 LOG(LS_INFO) << "Channel disabled"; 672 enabled_ = false; 673 ChangeState(); 674 } 675 676 bool BaseChannel::MuteStream_w(uint32 ssrc, bool mute) { 677 ASSERT(worker_thread_ == rtc::Thread::Current()); 678 bool ret = media_channel()->MuteStream(ssrc, mute); 679 if (ret) { 680 if (mute) 681 muted_streams_.insert(ssrc); 682 else 683 muted_streams_.erase(ssrc); 684 } 685 return ret; 686 } 687 688 bool BaseChannel::IsStreamMuted_w(uint32 ssrc) { 689 ASSERT(worker_thread_ == rtc::Thread::Current()); 690 return muted_streams_.find(ssrc) != muted_streams_.end(); 691 } 692 693 void BaseChannel::ChannelWritable_w() { 694 ASSERT(worker_thread_ == rtc::Thread::Current()); 695 if (writable_) 696 return; 697 698 LOG(LS_INFO) << "Channel socket writable (" 699 << transport_channel_->content_name() << ", " 700 << transport_channel_->component() << ")" 701 << (was_ever_writable_ ? "" : " for the first time"); 702 703 std::vector<ConnectionInfo> infos; 704 transport_channel_->GetStats(&infos); 705 for (std::vector<ConnectionInfo>::const_iterator it = infos.begin(); 706 it != infos.end(); ++it) { 707 if (it->best_connection) { 708 LOG(LS_INFO) << "Using " << it->local_candidate.ToSensitiveString() 709 << "->" << it->remote_candidate.ToSensitiveString(); 710 break; 711 } 712 } 713 714 // If we're doing DTLS-SRTP, now is the time. 715 if (!was_ever_writable_ && ShouldSetupDtlsSrtp()) { 716 if (!SetupDtlsSrtp(false)) { 717 const std::string error_desc = 718 "Couldn't set up DTLS-SRTP on RTP channel."; 719 // Sent synchronously. 720 signaling_thread()->Invoke<void>(Bind( 721 &SetSessionError, 722 session_, 723 BaseSession::ERROR_TRANSPORT, 724 error_desc)); 725 return; 726 } 727 728 if (rtcp_transport_channel_) { 729 if (!SetupDtlsSrtp(true)) { 730 const std::string error_desc = 731 "Couldn't set up DTLS-SRTP on RTCP channel"; 732 // Sent synchronously. 733 signaling_thread()->Invoke<void>(Bind( 734 &SetSessionError, 735 session_, 736 BaseSession::ERROR_TRANSPORT, 737 error_desc)); 738 return; 739 } 740 } 741 } 742 743 was_ever_writable_ = true; 744 writable_ = true; 745 ChangeState(); 746 } 747 748 bool BaseChannel::SetDtlsSrtpCiphers(TransportChannel *tc, bool rtcp) { 749 std::vector<std::string> ciphers; 750 // We always use the default SRTP ciphers for RTCP, but we may use different 751 // ciphers for RTP depending on the media type. 752 if (!rtcp) { 753 GetSrtpCiphers(&ciphers); 754 } else { 755 GetSupportedDefaultCryptoSuites(&ciphers); 756 } 757 return tc->SetSrtpCiphers(ciphers); 758 } 759 760 bool BaseChannel::ShouldSetupDtlsSrtp() const { 761 return true; 762 } 763 764 // This function returns true if either DTLS-SRTP is not in use 765 // *or* DTLS-SRTP is successfully set up. 766 bool BaseChannel::SetupDtlsSrtp(bool rtcp_channel) { 767 bool ret = false; 768 769 TransportChannel *channel = rtcp_channel ? 770 rtcp_transport_channel_ : transport_channel_; 771 772 // No DTLS 773 if (!channel->IsDtlsActive()) 774 return true; 775 776 std::string selected_cipher; 777 778 if (!channel->GetSrtpCipher(&selected_cipher)) { 779 LOG(LS_ERROR) << "No DTLS-SRTP selected cipher"; 780 return false; 781 } 782 783 LOG(LS_INFO) << "Installing keys from DTLS-SRTP on " 784 << content_name() << " " 785 << PacketType(rtcp_channel); 786 787 // OK, we're now doing DTLS (RFC 5764) 788 std::vector<unsigned char> dtls_buffer(SRTP_MASTER_KEY_KEY_LEN * 2 + 789 SRTP_MASTER_KEY_SALT_LEN * 2); 790 791 // RFC 5705 exporter using the RFC 5764 parameters 792 if (!channel->ExportKeyingMaterial( 793 kDtlsSrtpExporterLabel, 794 NULL, 0, false, 795 &dtls_buffer[0], dtls_buffer.size())) { 796 LOG(LS_WARNING) << "DTLS-SRTP key export failed"; 797 ASSERT(false); // This should never happen 798 return false; 799 } 800 801 // Sync up the keys with the DTLS-SRTP interface 802 std::vector<unsigned char> client_write_key(SRTP_MASTER_KEY_KEY_LEN + 803 SRTP_MASTER_KEY_SALT_LEN); 804 std::vector<unsigned char> server_write_key(SRTP_MASTER_KEY_KEY_LEN + 805 SRTP_MASTER_KEY_SALT_LEN); 806 size_t offset = 0; 807 memcpy(&client_write_key[0], &dtls_buffer[offset], 808 SRTP_MASTER_KEY_KEY_LEN); 809 offset += SRTP_MASTER_KEY_KEY_LEN; 810 memcpy(&server_write_key[0], &dtls_buffer[offset], 811 SRTP_MASTER_KEY_KEY_LEN); 812 offset += SRTP_MASTER_KEY_KEY_LEN; 813 memcpy(&client_write_key[SRTP_MASTER_KEY_KEY_LEN], 814 &dtls_buffer[offset], SRTP_MASTER_KEY_SALT_LEN); 815 offset += SRTP_MASTER_KEY_SALT_LEN; 816 memcpy(&server_write_key[SRTP_MASTER_KEY_KEY_LEN], 817 &dtls_buffer[offset], SRTP_MASTER_KEY_SALT_LEN); 818 819 std::vector<unsigned char> *send_key, *recv_key; 820 rtc::SSLRole role; 821 if (!channel->GetSslRole(&role)) { 822 LOG(LS_WARNING) << "GetSslRole failed"; 823 return false; 824 } 825 826 if (role == rtc::SSL_SERVER) { 827 send_key = &server_write_key; 828 recv_key = &client_write_key; 829 } else { 830 send_key = &client_write_key; 831 recv_key = &server_write_key; 832 } 833 834 if (rtcp_channel) { 835 ret = srtp_filter_.SetRtcpParams( 836 selected_cipher, 837 &(*send_key)[0], 838 static_cast<int>(send_key->size()), 839 selected_cipher, 840 &(*recv_key)[0], 841 static_cast<int>(recv_key->size())); 842 } else { 843 ret = srtp_filter_.SetRtpParams( 844 selected_cipher, 845 &(*send_key)[0], 846 static_cast<int>(send_key->size()), 847 selected_cipher, 848 &(*recv_key)[0], 849 static_cast<int>(recv_key->size())); 850 } 851 852 if (!ret) 853 LOG(LS_WARNING) << "DTLS-SRTP key installation failed"; 854 else 855 dtls_keyed_ = true; 856 857 return ret; 858 } 859 860 void BaseChannel::ChannelNotWritable_w() { 861 ASSERT(worker_thread_ == rtc::Thread::Current()); 862 if (!writable_) 863 return; 864 865 LOG(LS_INFO) << "Channel socket not writable (" 866 << transport_channel_->content_name() << ", " 867 << transport_channel_->component() << ")"; 868 writable_ = false; 869 ChangeState(); 870 } 871 872 // |dtls| will be set to true if DTLS is active for transport channel and 873 // crypto is empty. 874 bool BaseChannel::CheckSrtpConfig(const std::vector<CryptoParams>& cryptos, 875 bool* dtls, 876 std::string* error_desc) { 877 *dtls = transport_channel_->IsDtlsActive(); 878 if (*dtls && !cryptos.empty()) { 879 SafeSetError("Cryptos must be empty when DTLS is active.", 880 error_desc); 881 return false; 882 } 883 return true; 884 } 885 886 bool BaseChannel::SetRecvRtpHeaderExtensions_w( 887 const MediaContentDescription* content, 888 MediaChannel* media_channel, 889 std::string* error_desc) { 890 if (content->rtp_header_extensions_set()) { 891 if (!media_channel->SetRecvRtpHeaderExtensions( 892 content->rtp_header_extensions())) { 893 std::ostringstream desc; 894 desc << "Failed to set receive rtp header extensions for " 895 << MediaTypeToString(content->type()) << " content."; 896 SafeSetError(desc.str(), error_desc); 897 return false; 898 } 899 } 900 return true; 901 } 902 903 bool BaseChannel::SetSendRtpHeaderExtensions_w( 904 const MediaContentDescription* content, 905 MediaChannel* media_channel, 906 std::string* error_desc) { 907 if (content->rtp_header_extensions_set()) { 908 if (!media_channel->SetSendRtpHeaderExtensions( 909 content->rtp_header_extensions())) { 910 std::ostringstream desc; 911 desc << "Failed to set send rtp header extensions for " 912 << MediaTypeToString(content->type()) << " content."; 913 SafeSetError(desc.str(), error_desc); 914 return false; 915 } else { 916 MaybeCacheRtpAbsSendTimeHeaderExtension(content->rtp_header_extensions()); 917 } 918 } 919 return true; 920 } 921 922 bool BaseChannel::SetSrtp_w(const std::vector<CryptoParams>& cryptos, 923 ContentAction action, 924 ContentSource src, 925 std::string* error_desc) { 926 if (action == CA_UPDATE) { 927 // no crypto params. 928 return true; 929 } 930 bool ret = false; 931 bool dtls = false; 932 ret = CheckSrtpConfig(cryptos, &dtls, error_desc); 933 if (!ret) { 934 return false; 935 } 936 switch (action) { 937 case CA_OFFER: 938 // If DTLS is already active on the channel, we could be renegotiating 939 // here. We don't update the srtp filter. 940 if (!dtls) { 941 ret = srtp_filter_.SetOffer(cryptos, src); 942 } 943 break; 944 case CA_PRANSWER: 945 // If we're doing DTLS-SRTP, we don't want to update the filter 946 // with an answer, because we already have SRTP parameters. 947 if (!dtls) { 948 ret = srtp_filter_.SetProvisionalAnswer(cryptos, src); 949 } 950 break; 951 case CA_ANSWER: 952 // If we're doing DTLS-SRTP, we don't want to update the filter 953 // with an answer, because we already have SRTP parameters. 954 if (!dtls) { 955 ret = srtp_filter_.SetAnswer(cryptos, src); 956 } 957 break; 958 default: 959 break; 960 } 961 if (!ret) { 962 SafeSetError("Failed to setup SRTP filter.", error_desc); 963 return false; 964 } 965 return true; 966 } 967 968 bool BaseChannel::SetRtcpMux_w(bool enable, ContentAction action, 969 ContentSource src, 970 std::string* error_desc) { 971 bool ret = false; 972 switch (action) { 973 case CA_OFFER: 974 ret = rtcp_mux_filter_.SetOffer(enable, src); 975 break; 976 case CA_PRANSWER: 977 ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src); 978 break; 979 case CA_ANSWER: 980 ret = rtcp_mux_filter_.SetAnswer(enable, src); 981 if (ret && rtcp_mux_filter_.IsActive()) { 982 // We activated RTCP mux, close down the RTCP transport. 983 set_rtcp_transport_channel(NULL); 984 } 985 break; 986 case CA_UPDATE: 987 // No RTCP mux info. 988 ret = true; 989 default: 990 break; 991 } 992 if (!ret) { 993 SafeSetError("Failed to setup RTCP mux filter.", error_desc); 994 return false; 995 } 996 // |rtcp_mux_filter_| can be active if |action| is CA_PRANSWER or 997 // CA_ANSWER, but we only want to tear down the RTCP transport channel if we 998 // received a final answer. 999 if (rtcp_mux_filter_.IsActive()) { 1000 // If the RTP transport is already writable, then so are we. 1001 if (transport_channel_->writable()) { 1002 ChannelWritable_w(); 1003 } 1004 } 1005 1006 return true; 1007 } 1008 1009 bool BaseChannel::AddRecvStream_w(const StreamParams& sp) { 1010 ASSERT(worker_thread() == rtc::Thread::Current()); 1011 if (!media_channel()->AddRecvStream(sp)) 1012 return false; 1013 1014 return bundle_filter_.AddStream(sp); 1015 } 1016 1017 bool BaseChannel::RemoveRecvStream_w(uint32 ssrc) { 1018 ASSERT(worker_thread() == rtc::Thread::Current()); 1019 bundle_filter_.RemoveStream(ssrc); 1020 return media_channel()->RemoveRecvStream(ssrc); 1021 } 1022 1023 bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams, 1024 ContentAction action, 1025 std::string* error_desc) { 1026 if (!VERIFY(action == CA_OFFER || action == CA_ANSWER || 1027 action == CA_PRANSWER || action == CA_UPDATE)) 1028 return false; 1029 1030 // If this is an update, streams only contain streams that have changed. 1031 if (action == CA_UPDATE) { 1032 for (StreamParamsVec::const_iterator it = streams.begin(); 1033 it != streams.end(); ++it) { 1034 StreamParams existing_stream; 1035 bool stream_exist = GetStreamByIds(local_streams_, it->groupid, 1036 it->id, &existing_stream); 1037 if (!stream_exist && it->has_ssrcs()) { 1038 if (media_channel()->AddSendStream(*it)) { 1039 local_streams_.push_back(*it); 1040 LOG(LS_INFO) << "Add send stream ssrc: " << it->first_ssrc(); 1041 } else { 1042 std::ostringstream desc; 1043 desc << "Failed to add send stream ssrc: " << it->first_ssrc(); 1044 SafeSetError(desc.str(), error_desc); 1045 return false; 1046 } 1047 } else if (stream_exist && !it->has_ssrcs()) { 1048 if (!media_channel()->RemoveSendStream(existing_stream.first_ssrc())) { 1049 std::ostringstream desc; 1050 desc << "Failed to remove send stream with ssrc " 1051 << it->first_ssrc() << "."; 1052 SafeSetError(desc.str(), error_desc); 1053 return false; 1054 } 1055 RemoveStreamBySsrc(&local_streams_, existing_stream.first_ssrc()); 1056 } else { 1057 LOG(LS_WARNING) << "Ignore unsupported stream update"; 1058 } 1059 } 1060 return true; 1061 } 1062 // Else streams are all the streams we want to send. 1063 1064 // Check for streams that have been removed. 1065 bool ret = true; 1066 for (StreamParamsVec::const_iterator it = local_streams_.begin(); 1067 it != local_streams_.end(); ++it) { 1068 if (!GetStreamBySsrc(streams, it->first_ssrc(), NULL)) { 1069 if (!media_channel()->RemoveSendStream(it->first_ssrc())) { 1070 std::ostringstream desc; 1071 desc << "Failed to remove send stream with ssrc " 1072 << it->first_ssrc() << "."; 1073 SafeSetError(desc.str(), error_desc); 1074 ret = false; 1075 } 1076 } 1077 } 1078 // Check for new streams. 1079 for (StreamParamsVec::const_iterator it = streams.begin(); 1080 it != streams.end(); ++it) { 1081 if (!GetStreamBySsrc(local_streams_, it->first_ssrc(), NULL)) { 1082 if (media_channel()->AddSendStream(*it)) { 1083 LOG(LS_INFO) << "Add send ssrc: " << it->ssrcs[0]; 1084 } else { 1085 std::ostringstream desc; 1086 desc << "Failed to add send stream ssrc: " << it->first_ssrc(); 1087 SafeSetError(desc.str(), error_desc); 1088 ret = false; 1089 } 1090 } 1091 } 1092 local_streams_ = streams; 1093 return ret; 1094 } 1095 1096 bool BaseChannel::UpdateRemoteStreams_w( 1097 const std::vector<StreamParams>& streams, 1098 ContentAction action, 1099 std::string* error_desc) { 1100 if (!VERIFY(action == CA_OFFER || action == CA_ANSWER || 1101 action == CA_PRANSWER || action == CA_UPDATE)) 1102 return false; 1103 1104 // If this is an update, streams only contain streams that have changed. 1105 if (action == CA_UPDATE) { 1106 for (StreamParamsVec::const_iterator it = streams.begin(); 1107 it != streams.end(); ++it) { 1108 StreamParams existing_stream; 1109 bool stream_exists = GetStreamByIds(remote_streams_, it->groupid, 1110 it->id, &existing_stream); 1111 if (!stream_exists && it->has_ssrcs()) { 1112 if (AddRecvStream_w(*it)) { 1113 remote_streams_.push_back(*it); 1114 LOG(LS_INFO) << "Add remote stream ssrc: " << it->first_ssrc(); 1115 } else { 1116 std::ostringstream desc; 1117 desc << "Failed to add remote stream ssrc: " << it->first_ssrc(); 1118 SafeSetError(desc.str(), error_desc); 1119 return false; 1120 } 1121 } else if (stream_exists && !it->has_ssrcs()) { 1122 if (!RemoveRecvStream_w(existing_stream.first_ssrc())) { 1123 std::ostringstream desc; 1124 desc << "Failed to remove remote stream with ssrc " 1125 << it->first_ssrc() << "."; 1126 SafeSetError(desc.str(), error_desc); 1127 return false; 1128 } 1129 RemoveStreamBySsrc(&remote_streams_, existing_stream.first_ssrc()); 1130 } else { 1131 LOG(LS_WARNING) << "Ignore unsupported stream update." 1132 << " Stream exists? " << stream_exists 1133 << " existing stream = " << existing_stream.ToString() 1134 << " new stream = " << it->ToString(); 1135 } 1136 } 1137 return true; 1138 } 1139 // Else streams are all the streams we want to receive. 1140 1141 // Check for streams that have been removed. 1142 bool ret = true; 1143 for (StreamParamsVec::const_iterator it = remote_streams_.begin(); 1144 it != remote_streams_.end(); ++it) { 1145 if (!GetStreamBySsrc(streams, it->first_ssrc(), NULL)) { 1146 if (!RemoveRecvStream_w(it->first_ssrc())) { 1147 std::ostringstream desc; 1148 desc << "Failed to remove remote stream with ssrc " 1149 << it->first_ssrc() << "."; 1150 SafeSetError(desc.str(), error_desc); 1151 ret = false; 1152 } 1153 } 1154 } 1155 // Check for new streams. 1156 for (StreamParamsVec::const_iterator it = streams.begin(); 1157 it != streams.end(); ++it) { 1158 if (!GetStreamBySsrc(remote_streams_, it->first_ssrc(), NULL)) { 1159 if (AddRecvStream_w(*it)) { 1160 LOG(LS_INFO) << "Add remote ssrc: " << it->ssrcs[0]; 1161 } else { 1162 std::ostringstream desc; 1163 desc << "Failed to add remote stream ssrc: " << it->first_ssrc(); 1164 SafeSetError(desc.str(), error_desc); 1165 ret = false; 1166 } 1167 } 1168 } 1169 remote_streams_ = streams; 1170 return ret; 1171 } 1172 1173 bool BaseChannel::SetBaseLocalContent_w(const MediaContentDescription* content, 1174 ContentAction action, 1175 std::string* error_desc) { 1176 // Cache secure_required_ for belt and suspenders check on SendPacket 1177 secure_required_ = content->crypto_required() != CT_NONE; 1178 // Set local RTP header extensions. 1179 bool ret = SetRecvRtpHeaderExtensions_w(content, media_channel(), error_desc); 1180 // Set local SRTP parameters (what we will encrypt with). 1181 ret &= SetSrtp_w(content->cryptos(), action, CS_LOCAL, error_desc); 1182 // Set local RTCP mux parameters. 1183 ret &= SetRtcpMux_w(content->rtcp_mux(), action, CS_LOCAL, error_desc); 1184 1185 // Call UpdateLocalStreams_w last to make sure as many settings as possible 1186 // are already set when creating streams. 1187 ret &= UpdateLocalStreams_w(content->streams(), action, error_desc); 1188 set_local_content_direction(content->direction()); 1189 return ret; 1190 } 1191 1192 bool BaseChannel::SetBaseRemoteContent_w(const MediaContentDescription* content, 1193 ContentAction action, 1194 std::string* error_desc) { 1195 // Set remote RTP header extensions. 1196 bool ret = SetSendRtpHeaderExtensions_w(content, media_channel(), error_desc); 1197 // Set remote SRTP parameters (what the other side will encrypt with). 1198 ret &= SetSrtp_w(content->cryptos(), action, CS_REMOTE, error_desc); 1199 // Set remote RTCP mux parameters. 1200 ret &= SetRtcpMux_w(content->rtcp_mux(), action, CS_REMOTE, error_desc); 1201 if (!media_channel()->SetMaxSendBandwidth(content->bandwidth())) { 1202 std::ostringstream desc; 1203 desc << "Failed to set max send bandwidth for " 1204 << MediaTypeToString(content->type()) << " content."; 1205 SafeSetError(desc.str(), error_desc); 1206 ret = false; 1207 } 1208 1209 // Call UpdateRemoteStreams_w last to make sure as many settings as possible 1210 // are already set when creating streams. 1211 ret &= UpdateRemoteStreams_w(content->streams(), action, error_desc); 1212 set_remote_content_direction(content->direction()); 1213 return ret; 1214 } 1215 1216 void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension( 1217 const std::vector<RtpHeaderExtension>& extensions) { 1218 const RtpHeaderExtension* send_time_extension = 1219 FindHeaderExtension(extensions, kRtpAbsoluteSenderTimeHeaderExtension); 1220 rtp_abs_sendtime_extn_id_ = 1221 send_time_extension ? send_time_extension->id : -1; 1222 } 1223 1224 void BaseChannel::OnMessage(rtc::Message *pmsg) { 1225 switch (pmsg->message_id) { 1226 case MSG_RTPPACKET: 1227 case MSG_RTCPPACKET: { 1228 PacketMessageData* data = static_cast<PacketMessageData*>(pmsg->pdata); 1229 SendPacket(pmsg->message_id == MSG_RTCPPACKET, &data->packet, data->dscp); 1230 delete data; // because it is Posted 1231 break; 1232 } 1233 case MSG_FIRSTPACKETRECEIVED: { 1234 SignalFirstPacketReceived(this); 1235 break; 1236 } 1237 } 1238 } 1239 1240 void BaseChannel::FlushRtcpMessages() { 1241 // Flush all remaining RTCP messages. This should only be called in 1242 // destructor. 1243 ASSERT(rtc::Thread::Current() == worker_thread_); 1244 rtc::MessageList rtcp_messages; 1245 worker_thread_->Clear(this, MSG_RTCPPACKET, &rtcp_messages); 1246 for (rtc::MessageList::iterator it = rtcp_messages.begin(); 1247 it != rtcp_messages.end(); ++it) { 1248 worker_thread_->Send(this, MSG_RTCPPACKET, it->pdata); 1249 } 1250 } 1251 1252 VoiceChannel::VoiceChannel(rtc::Thread* thread, 1253 MediaEngineInterface* media_engine, 1254 VoiceMediaChannel* media_channel, 1255 BaseSession* session, 1256 const std::string& content_name, 1257 bool rtcp) 1258 : BaseChannel(thread, media_engine, media_channel, session, content_name, 1259 rtcp), 1260 received_media_(false) { 1261 } 1262 1263 VoiceChannel::~VoiceChannel() { 1264 StopAudioMonitor(); 1265 StopMediaMonitor(); 1266 // this can't be done in the base class, since it calls a virtual 1267 DisableMedia_w(); 1268 Deinit(); 1269 } 1270 1271 bool VoiceChannel::Init() { 1272 TransportChannel* rtcp_channel = rtcp() ? session()->CreateChannel( 1273 content_name(), "rtcp", ICE_CANDIDATE_COMPONENT_RTCP) : NULL; 1274 if (!BaseChannel::Init(session()->CreateChannel( 1275 content_name(), "rtp", ICE_CANDIDATE_COMPONENT_RTP), 1276 rtcp_channel)) { 1277 return false; 1278 } 1279 media_channel()->SignalMediaError.connect( 1280 this, &VoiceChannel::OnVoiceChannelError); 1281 srtp_filter()->SignalSrtpError.connect( 1282 this, &VoiceChannel::OnSrtpError); 1283 return true; 1284 } 1285 1286 bool VoiceChannel::SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) { 1287 return InvokeOnWorker(Bind(&VoiceMediaChannel::SetRemoteRenderer, 1288 media_channel(), ssrc, renderer)); 1289 } 1290 1291 bool VoiceChannel::SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) { 1292 return InvokeOnWorker(Bind(&VoiceMediaChannel::SetLocalRenderer, 1293 media_channel(), ssrc, renderer)); 1294 } 1295 1296 bool VoiceChannel::SetRingbackTone(const void* buf, int len) { 1297 return InvokeOnWorker(Bind(&VoiceChannel::SetRingbackTone_w, this, buf, len)); 1298 } 1299 1300 // TODO(juberti): Handle early media the right way. We should get an explicit 1301 // ringing message telling us to start playing local ringback, which we cancel 1302 // if any early media actually arrives. For now, we do the opposite, which is 1303 // to wait 1 second for early media, and start playing local ringback if none 1304 // arrives. 1305 void VoiceChannel::SetEarlyMedia(bool enable) { 1306 if (enable) { 1307 // Start the early media timeout 1308 worker_thread()->PostDelayed(kEarlyMediaTimeout, this, 1309 MSG_EARLYMEDIATIMEOUT); 1310 } else { 1311 // Stop the timeout if currently going. 1312 worker_thread()->Clear(this, MSG_EARLYMEDIATIMEOUT); 1313 } 1314 } 1315 1316 bool VoiceChannel::PlayRingbackTone(uint32 ssrc, bool play, bool loop) { 1317 return InvokeOnWorker(Bind(&VoiceChannel::PlayRingbackTone_w, 1318 this, ssrc, play, loop)); 1319 } 1320 1321 bool VoiceChannel::PressDTMF(int digit, bool playout) { 1322 int flags = DF_SEND; 1323 if (playout) { 1324 flags |= DF_PLAY; 1325 } 1326 int duration_ms = 160; 1327 return InsertDtmf(0, digit, duration_ms, flags); 1328 } 1329 1330 bool VoiceChannel::CanInsertDtmf() { 1331 return InvokeOnWorker(Bind(&VoiceMediaChannel::CanInsertDtmf, 1332 media_channel())); 1333 } 1334 1335 bool VoiceChannel::InsertDtmf(uint32 ssrc, int event_code, int duration, 1336 int flags) { 1337 return InvokeOnWorker(Bind(&VoiceChannel::InsertDtmf_w, this, 1338 ssrc, event_code, duration, flags)); 1339 } 1340 1341 bool VoiceChannel::SetOutputScaling(uint32 ssrc, double left, double right) { 1342 return InvokeOnWorker(Bind(&VoiceMediaChannel::SetOutputScaling, 1343 media_channel(), ssrc, left, right)); 1344 } 1345 1346 bool VoiceChannel::GetStats(VoiceMediaInfo* stats) { 1347 return InvokeOnWorker(Bind(&VoiceMediaChannel::GetStats, 1348 media_channel(), stats)); 1349 } 1350 1351 void VoiceChannel::StartMediaMonitor(int cms) { 1352 media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(), 1353 rtc::Thread::Current())); 1354 media_monitor_->SignalUpdate.connect( 1355 this, &VoiceChannel::OnMediaMonitorUpdate); 1356 media_monitor_->Start(cms); 1357 } 1358 1359 void VoiceChannel::StopMediaMonitor() { 1360 if (media_monitor_) { 1361 media_monitor_->Stop(); 1362 media_monitor_->SignalUpdate.disconnect(this); 1363 media_monitor_.reset(); 1364 } 1365 } 1366 1367 void VoiceChannel::StartAudioMonitor(int cms) { 1368 audio_monitor_.reset(new AudioMonitor(this, rtc::Thread::Current())); 1369 audio_monitor_ 1370 ->SignalUpdate.connect(this, &VoiceChannel::OnAudioMonitorUpdate); 1371 audio_monitor_->Start(cms); 1372 } 1373 1374 void VoiceChannel::StopAudioMonitor() { 1375 if (audio_monitor_) { 1376 audio_monitor_->Stop(); 1377 audio_monitor_.reset(); 1378 } 1379 } 1380 1381 bool VoiceChannel::IsAudioMonitorRunning() const { 1382 return (audio_monitor_.get() != NULL); 1383 } 1384 1385 void VoiceChannel::StartTypingMonitor(const TypingMonitorOptions& settings) { 1386 typing_monitor_.reset(new TypingMonitor(this, worker_thread(), settings)); 1387 SignalAutoMuted.repeat(typing_monitor_->SignalMuted); 1388 } 1389 1390 void VoiceChannel::StopTypingMonitor() { 1391 typing_monitor_.reset(); 1392 } 1393 1394 bool VoiceChannel::IsTypingMonitorRunning() const { 1395 return typing_monitor_; 1396 } 1397 1398 bool VoiceChannel::MuteStream_w(uint32 ssrc, bool mute) { 1399 bool ret = BaseChannel::MuteStream_w(ssrc, mute); 1400 if (typing_monitor_ && mute) 1401 typing_monitor_->OnChannelMuted(); 1402 return ret; 1403 } 1404 1405 int VoiceChannel::GetInputLevel_w() { 1406 return media_engine()->GetInputLevel(); 1407 } 1408 1409 int VoiceChannel::GetOutputLevel_w() { 1410 return media_channel()->GetOutputLevel(); 1411 } 1412 1413 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) { 1414 media_channel()->GetActiveStreams(actives); 1415 } 1416 1417 void VoiceChannel::OnChannelRead(TransportChannel* channel, 1418 const char* data, size_t len, 1419 const rtc::PacketTime& packet_time, 1420 int flags) { 1421 BaseChannel::OnChannelRead(channel, data, len, packet_time, flags); 1422 1423 // Set a flag when we've received an RTP packet. If we're waiting for early 1424 // media, this will disable the timeout. 1425 if (!received_media_ && !PacketIsRtcp(channel, data, len)) { 1426 received_media_ = true; 1427 } 1428 } 1429 1430 void VoiceChannel::ChangeState() { 1431 // Render incoming data if we're the active call, and we have the local 1432 // content. We receive data on the default channel and multiplexed streams. 1433 bool recv = IsReadyToReceive(); 1434 if (!media_channel()->SetPlayout(recv)) { 1435 SendLastMediaError(); 1436 } 1437 1438 // Send outgoing data if we're the active call, we have the remote content, 1439 // and we have had some form of connectivity. 1440 bool send = IsReadyToSend(); 1441 SendFlags send_flag = send ? SEND_MICROPHONE : SEND_NOTHING; 1442 if (!media_channel()->SetSend(send_flag)) { 1443 LOG(LS_ERROR) << "Failed to SetSend " << send_flag << " on voice channel"; 1444 SendLastMediaError(); 1445 } 1446 1447 LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send; 1448 } 1449 1450 const ContentInfo* VoiceChannel::GetFirstContent( 1451 const SessionDescription* sdesc) { 1452 return GetFirstAudioContent(sdesc); 1453 } 1454 1455 bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content, 1456 ContentAction action, 1457 std::string* error_desc) { 1458 ASSERT(worker_thread() == rtc::Thread::Current()); 1459 LOG(LS_INFO) << "Setting local voice description"; 1460 1461 const AudioContentDescription* audio = 1462 static_cast<const AudioContentDescription*>(content); 1463 ASSERT(audio != NULL); 1464 if (!audio) { 1465 SafeSetError("Can't find audio content in local description.", error_desc); 1466 return false; 1467 } 1468 1469 bool ret = SetBaseLocalContent_w(content, action, error_desc); 1470 // Set local audio codecs (what we want to receive). 1471 // TODO(whyuan): Change action != CA_UPDATE to !audio->partial() when partial 1472 // is set properly. 1473 if (action != CA_UPDATE || audio->has_codecs()) { 1474 if (!media_channel()->SetRecvCodecs(audio->codecs())) { 1475 SafeSetError("Failed to set audio receive codecs.", error_desc); 1476 ret = false; 1477 } 1478 } 1479 1480 // If everything worked, see if we can start receiving. 1481 if (ret) { 1482 std::vector<AudioCodec>::const_iterator it = audio->codecs().begin(); 1483 for (; it != audio->codecs().end(); ++it) { 1484 bundle_filter()->AddPayloadType(it->id); 1485 } 1486 ChangeState(); 1487 } else { 1488 LOG(LS_WARNING) << "Failed to set local voice description"; 1489 } 1490 return ret; 1491 } 1492 1493 bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content, 1494 ContentAction action, 1495 std::string* error_desc) { 1496 ASSERT(worker_thread() == rtc::Thread::Current()); 1497 LOG(LS_INFO) << "Setting remote voice description"; 1498 1499 const AudioContentDescription* audio = 1500 static_cast<const AudioContentDescription*>(content); 1501 ASSERT(audio != NULL); 1502 if (!audio) { 1503 SafeSetError("Can't find audio content in remote description.", error_desc); 1504 return false; 1505 } 1506 1507 bool ret = true; 1508 // Set remote video codecs (what the other side wants to receive). 1509 if (action != CA_UPDATE || audio->has_codecs()) { 1510 if (!media_channel()->SetSendCodecs(audio->codecs())) { 1511 SafeSetError("Failed to set audio send codecs.", error_desc); 1512 ret = false; 1513 } 1514 } 1515 1516 ret &= SetBaseRemoteContent_w(content, action, error_desc); 1517 1518 if (action != CA_UPDATE) { 1519 // Tweak our audio processing settings, if needed. 1520 AudioOptions audio_options; 1521 if (!media_channel()->GetOptions(&audio_options)) { 1522 LOG(LS_WARNING) << "Can not set audio options from on remote content."; 1523 } else { 1524 if (audio->conference_mode()) { 1525 audio_options.conference_mode.Set(true); 1526 } 1527 if (audio->agc_minus_10db()) { 1528 audio_options.adjust_agc_delta.Set(kAgcMinus10db); 1529 } 1530 if (!media_channel()->SetOptions(audio_options)) { 1531 // Log an error on failure, but don't abort the call. 1532 LOG(LS_ERROR) << "Failed to set voice channel options"; 1533 } 1534 } 1535 } 1536 1537 // If everything worked, see if we can start sending. 1538 if (ret) { 1539 ChangeState(); 1540 } else { 1541 LOG(LS_WARNING) << "Failed to set remote voice description"; 1542 } 1543 return ret; 1544 } 1545 1546 bool VoiceChannel::SetRingbackTone_w(const void* buf, int len) { 1547 ASSERT(worker_thread() == rtc::Thread::Current()); 1548 return media_channel()->SetRingbackTone(static_cast<const char*>(buf), len); 1549 } 1550 1551 bool VoiceChannel::PlayRingbackTone_w(uint32 ssrc, bool play, bool loop) { 1552 ASSERT(worker_thread() == rtc::Thread::Current()); 1553 if (play) { 1554 LOG(LS_INFO) << "Playing ringback tone, loop=" << loop; 1555 } else { 1556 LOG(LS_INFO) << "Stopping ringback tone"; 1557 } 1558 return media_channel()->PlayRingbackTone(ssrc, play, loop); 1559 } 1560 1561 void VoiceChannel::HandleEarlyMediaTimeout() { 1562 // This occurs on the main thread, not the worker thread. 1563 if (!received_media_) { 1564 LOG(LS_INFO) << "No early media received before timeout"; 1565 SignalEarlyMediaTimeout(this); 1566 } 1567 } 1568 1569 bool VoiceChannel::InsertDtmf_w(uint32 ssrc, int event, int duration, 1570 int flags) { 1571 if (!enabled()) { 1572 return false; 1573 } 1574 1575 return media_channel()->InsertDtmf(ssrc, event, duration, flags); 1576 } 1577 1578 bool VoiceChannel::SetChannelOptions(const AudioOptions& options) { 1579 return InvokeOnWorker(Bind(&VoiceMediaChannel::SetOptions, 1580 media_channel(), options)); 1581 } 1582 1583 void VoiceChannel::OnMessage(rtc::Message *pmsg) { 1584 switch (pmsg->message_id) { 1585 case MSG_EARLYMEDIATIMEOUT: 1586 HandleEarlyMediaTimeout(); 1587 break; 1588 case MSG_CHANNEL_ERROR: { 1589 VoiceChannelErrorMessageData* data = 1590 static_cast<VoiceChannelErrorMessageData*>(pmsg->pdata); 1591 SignalMediaError(this, data->ssrc, data->error); 1592 delete data; 1593 break; 1594 } 1595 default: 1596 BaseChannel::OnMessage(pmsg); 1597 break; 1598 } 1599 } 1600 1601 void VoiceChannel::OnConnectionMonitorUpdate( 1602 SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos) { 1603 SignalConnectionMonitor(this, infos); 1604 } 1605 1606 void VoiceChannel::OnMediaMonitorUpdate( 1607 VoiceMediaChannel* media_channel, const VoiceMediaInfo& info) { 1608 ASSERT(media_channel == this->media_channel()); 1609 SignalMediaMonitor(this, info); 1610 } 1611 1612 void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor, 1613 const AudioInfo& info) { 1614 SignalAudioMonitor(this, info); 1615 } 1616 1617 void VoiceChannel::OnVoiceChannelError( 1618 uint32 ssrc, VoiceMediaChannel::Error err) { 1619 VoiceChannelErrorMessageData* data = new VoiceChannelErrorMessageData( 1620 ssrc, err); 1621 signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data); 1622 } 1623 1624 void VoiceChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, 1625 SrtpFilter::Error error) { 1626 switch (error) { 1627 case SrtpFilter::ERROR_FAIL: 1628 OnVoiceChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 1629 VoiceMediaChannel::ERROR_REC_SRTP_ERROR : 1630 VoiceMediaChannel::ERROR_PLAY_SRTP_ERROR); 1631 break; 1632 case SrtpFilter::ERROR_AUTH: 1633 OnVoiceChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 1634 VoiceMediaChannel::ERROR_REC_SRTP_AUTH_FAILED : 1635 VoiceMediaChannel::ERROR_PLAY_SRTP_AUTH_FAILED); 1636 break; 1637 case SrtpFilter::ERROR_REPLAY: 1638 // Only receving channel should have this error. 1639 ASSERT(mode == SrtpFilter::UNPROTECT); 1640 OnVoiceChannelError(ssrc, VoiceMediaChannel::ERROR_PLAY_SRTP_REPLAY); 1641 break; 1642 default: 1643 break; 1644 } 1645 } 1646 1647 void VoiceChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const { 1648 GetSupportedAudioCryptoSuites(ciphers); 1649 } 1650 1651 VideoChannel::VideoChannel(rtc::Thread* thread, 1652 MediaEngineInterface* media_engine, 1653 VideoMediaChannel* media_channel, 1654 BaseSession* session, 1655 const std::string& content_name, 1656 bool rtcp, 1657 VoiceChannel* voice_channel) 1658 : BaseChannel(thread, media_engine, media_channel, session, content_name, 1659 rtcp), 1660 voice_channel_(voice_channel), 1661 renderer_(NULL), 1662 previous_we_(rtc::WE_CLOSE) { 1663 } 1664 1665 bool VideoChannel::Init() { 1666 TransportChannel* rtcp_channel = rtcp() ? session()->CreateChannel( 1667 content_name(), "video_rtcp", ICE_CANDIDATE_COMPONENT_RTCP) : NULL; 1668 if (!BaseChannel::Init(session()->CreateChannel( 1669 content_name(), "video_rtp", ICE_CANDIDATE_COMPONENT_RTP), 1670 rtcp_channel)) { 1671 return false; 1672 } 1673 media_channel()->SignalMediaError.connect( 1674 this, &VideoChannel::OnVideoChannelError); 1675 srtp_filter()->SignalSrtpError.connect( 1676 this, &VideoChannel::OnSrtpError); 1677 return true; 1678 } 1679 1680 void VoiceChannel::SendLastMediaError() { 1681 uint32 ssrc; 1682 VoiceMediaChannel::Error error; 1683 media_channel()->GetLastMediaError(&ssrc, &error); 1684 SignalMediaError(this, ssrc, error); 1685 } 1686 1687 VideoChannel::~VideoChannel() { 1688 std::vector<uint32> screencast_ssrcs; 1689 ScreencastMap::iterator iter; 1690 while (!screencast_capturers_.empty()) { 1691 if (!RemoveScreencast(screencast_capturers_.begin()->first)) { 1692 LOG(LS_ERROR) << "Unable to delete screencast with ssrc " 1693 << screencast_capturers_.begin()->first; 1694 ASSERT(false); 1695 break; 1696 } 1697 } 1698 1699 StopMediaMonitor(); 1700 // this can't be done in the base class, since it calls a virtual 1701 DisableMedia_w(); 1702 1703 Deinit(); 1704 } 1705 1706 bool VideoChannel::SetRenderer(uint32 ssrc, VideoRenderer* renderer) { 1707 worker_thread()->Invoke<void>(Bind( 1708 &VideoMediaChannel::SetRenderer, media_channel(), ssrc, renderer)); 1709 return true; 1710 } 1711 1712 bool VideoChannel::ApplyViewRequest(const ViewRequest& request) { 1713 return InvokeOnWorker(Bind(&VideoChannel::ApplyViewRequest_w, this, request)); 1714 } 1715 1716 bool VideoChannel::AddScreencast(uint32 ssrc, VideoCapturer* capturer) { 1717 return worker_thread()->Invoke<bool>(Bind( 1718 &VideoChannel::AddScreencast_w, this, ssrc, capturer)); 1719 } 1720 1721 bool VideoChannel::SetCapturer(uint32 ssrc, VideoCapturer* capturer) { 1722 return InvokeOnWorker(Bind(&VideoMediaChannel::SetCapturer, 1723 media_channel(), ssrc, capturer)); 1724 } 1725 1726 bool VideoChannel::RemoveScreencast(uint32 ssrc) { 1727 return InvokeOnWorker(Bind(&VideoChannel::RemoveScreencast_w, this, ssrc)); 1728 } 1729 1730 bool VideoChannel::IsScreencasting() { 1731 return InvokeOnWorker(Bind(&VideoChannel::IsScreencasting_w, this)); 1732 } 1733 1734 int VideoChannel::GetScreencastFps(uint32 ssrc) { 1735 ScreencastDetailsData data(ssrc); 1736 worker_thread()->Invoke<void>(Bind( 1737 &VideoChannel::GetScreencastDetails_w, this, &data)); 1738 return data.fps; 1739 } 1740 1741 int VideoChannel::GetScreencastMaxPixels(uint32 ssrc) { 1742 ScreencastDetailsData data(ssrc); 1743 worker_thread()->Invoke<void>(Bind( 1744 &VideoChannel::GetScreencastDetails_w, this, &data)); 1745 return data.screencast_max_pixels; 1746 } 1747 1748 bool VideoChannel::SendIntraFrame() { 1749 worker_thread()->Invoke<void>(Bind( 1750 &VideoMediaChannel::SendIntraFrame, media_channel())); 1751 return true; 1752 } 1753 1754 bool VideoChannel::RequestIntraFrame() { 1755 worker_thread()->Invoke<void>(Bind( 1756 &VideoMediaChannel::RequestIntraFrame, media_channel())); 1757 return true; 1758 } 1759 1760 void VideoChannel::ChangeState() { 1761 // Render incoming data if we're the active call, and we have the local 1762 // content. We receive data on the default channel and multiplexed streams. 1763 bool recv = IsReadyToReceive(); 1764 if (!media_channel()->SetRender(recv)) { 1765 LOG(LS_ERROR) << "Failed to SetRender on video channel"; 1766 // TODO(gangji): Report error back to server. 1767 } 1768 1769 // Send outgoing data if we're the active call, we have the remote content, 1770 // and we have had some form of connectivity. 1771 bool send = IsReadyToSend(); 1772 if (!media_channel()->SetSend(send)) { 1773 LOG(LS_ERROR) << "Failed to SetSend on video channel"; 1774 // TODO(gangji): Report error back to server. 1775 } 1776 1777 LOG(LS_INFO) << "Changing video state, recv=" << recv << " send=" << send; 1778 } 1779 1780 bool VideoChannel::GetStats( 1781 const StatsOptions& options, VideoMediaInfo* stats) { 1782 return InvokeOnWorker(Bind(&VideoMediaChannel::GetStats, 1783 media_channel(), options, stats)); 1784 } 1785 1786 void VideoChannel::StartMediaMonitor(int cms) { 1787 media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(), 1788 rtc::Thread::Current())); 1789 media_monitor_->SignalUpdate.connect( 1790 this, &VideoChannel::OnMediaMonitorUpdate); 1791 media_monitor_->Start(cms); 1792 } 1793 1794 void VideoChannel::StopMediaMonitor() { 1795 if (media_monitor_) { 1796 media_monitor_->Stop(); 1797 media_monitor_.reset(); 1798 } 1799 } 1800 1801 const ContentInfo* VideoChannel::GetFirstContent( 1802 const SessionDescription* sdesc) { 1803 return GetFirstVideoContent(sdesc); 1804 } 1805 1806 bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content, 1807 ContentAction action, 1808 std::string* error_desc) { 1809 ASSERT(worker_thread() == rtc::Thread::Current()); 1810 LOG(LS_INFO) << "Setting local video description"; 1811 1812 const VideoContentDescription* video = 1813 static_cast<const VideoContentDescription*>(content); 1814 ASSERT(video != NULL); 1815 if (!video) { 1816 SafeSetError("Can't find video content in local description.", error_desc); 1817 return false; 1818 } 1819 1820 bool ret = SetBaseLocalContent_w(content, action, error_desc); 1821 // Set local video codecs (what we want to receive). 1822 if (action != CA_UPDATE || video->has_codecs()) { 1823 if (!media_channel()->SetRecvCodecs(video->codecs())) { 1824 SafeSetError("Failed to set video receive codecs.", error_desc); 1825 ret = false; 1826 } 1827 } 1828 1829 if (action != CA_UPDATE) { 1830 VideoOptions video_options; 1831 media_channel()->GetOptions(&video_options); 1832 video_options.buffered_mode_latency.Set(video->buffered_mode_latency()); 1833 1834 if (!media_channel()->SetOptions(video_options)) { 1835 // Log an error on failure, but don't abort the call. 1836 LOG(LS_ERROR) << "Failed to set video channel options"; 1837 } 1838 } 1839 1840 // If everything worked, see if we can start receiving. 1841 if (ret) { 1842 std::vector<VideoCodec>::const_iterator it = video->codecs().begin(); 1843 for (; it != video->codecs().end(); ++it) { 1844 bundle_filter()->AddPayloadType(it->id); 1845 } 1846 ChangeState(); 1847 } else { 1848 LOG(LS_WARNING) << "Failed to set local video description"; 1849 } 1850 return ret; 1851 } 1852 1853 bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content, 1854 ContentAction action, 1855 std::string* error_desc) { 1856 ASSERT(worker_thread() == rtc::Thread::Current()); 1857 LOG(LS_INFO) << "Setting remote video description"; 1858 1859 const VideoContentDescription* video = 1860 static_cast<const VideoContentDescription*>(content); 1861 ASSERT(video != NULL); 1862 if (!video) { 1863 SafeSetError("Can't find video content in remote description.", error_desc); 1864 return false; 1865 } 1866 1867 bool ret = true; 1868 // Set remote video codecs (what the other side wants to receive). 1869 if (action != CA_UPDATE || video->has_codecs()) { 1870 if (!media_channel()->SetSendCodecs(video->codecs())) { 1871 SafeSetError("Failed to set video send codecs.", error_desc); 1872 ret = false; 1873 } 1874 } 1875 1876 ret &= SetBaseRemoteContent_w(content, action, error_desc); 1877 1878 if (action != CA_UPDATE) { 1879 // Tweak our video processing settings, if needed. 1880 VideoOptions video_options; 1881 media_channel()->GetOptions(&video_options); 1882 if (video->conference_mode()) { 1883 video_options.conference_mode.Set(true); 1884 } 1885 video_options.buffered_mode_latency.Set(video->buffered_mode_latency()); 1886 1887 if (!media_channel()->SetOptions(video_options)) { 1888 // Log an error on failure, but don't abort the call. 1889 LOG(LS_ERROR) << "Failed to set video channel options"; 1890 } 1891 } 1892 1893 // If everything worked, see if we can start sending. 1894 if (ret) { 1895 ChangeState(); 1896 } else { 1897 LOG(LS_WARNING) << "Failed to set remote video description"; 1898 } 1899 return ret; 1900 } 1901 1902 bool VideoChannel::ApplyViewRequest_w(const ViewRequest& request) { 1903 bool ret = true; 1904 // Set the send format for each of the local streams. If the view request 1905 // does not contain a local stream, set its send format to 0x0, which will 1906 // drop all frames. 1907 for (std::vector<StreamParams>::const_iterator it = local_streams().begin(); 1908 it != local_streams().end(); ++it) { 1909 VideoFormat format(0, 0, 0, cricket::FOURCC_I420); 1910 StaticVideoViews::const_iterator view; 1911 for (view = request.static_video_views.begin(); 1912 view != request.static_video_views.end(); ++view) { 1913 if (view->selector.Matches(*it)) { 1914 format.width = view->width; 1915 format.height = view->height; 1916 format.interval = cricket::VideoFormat::FpsToInterval(view->framerate); 1917 break; 1918 } 1919 } 1920 1921 ret &= media_channel()->SetSendStreamFormat(it->first_ssrc(), format); 1922 } 1923 1924 // Check if the view request has invalid streams. 1925 for (StaticVideoViews::const_iterator it = request.static_video_views.begin(); 1926 it != request.static_video_views.end(); ++it) { 1927 if (!GetStream(local_streams(), it->selector, NULL)) { 1928 LOG(LS_WARNING) << "View request for (" 1929 << it->selector.ssrc << ", '" 1930 << it->selector.groupid << "', '" 1931 << it->selector.streamid << "'" 1932 << ") is not in the local streams."; 1933 } 1934 } 1935 1936 return ret; 1937 } 1938 1939 bool VideoChannel::AddScreencast_w(uint32 ssrc, VideoCapturer* capturer) { 1940 if (screencast_capturers_.find(ssrc) != screencast_capturers_.end()) { 1941 return false; 1942 } 1943 capturer->SignalStateChange.connect(this, &VideoChannel::OnStateChange); 1944 screencast_capturers_[ssrc] = capturer; 1945 return true; 1946 } 1947 1948 bool VideoChannel::RemoveScreencast_w(uint32 ssrc) { 1949 ScreencastMap::iterator iter = screencast_capturers_.find(ssrc); 1950 if (iter == screencast_capturers_.end()) { 1951 return false; 1952 } 1953 // Clean up VideoCapturer. 1954 delete iter->second; 1955 screencast_capturers_.erase(iter); 1956 return true; 1957 } 1958 1959 bool VideoChannel::IsScreencasting_w() const { 1960 return !screencast_capturers_.empty(); 1961 } 1962 1963 void VideoChannel::GetScreencastDetails_w( 1964 ScreencastDetailsData* data) const { 1965 ScreencastMap::const_iterator iter = screencast_capturers_.find(data->ssrc); 1966 if (iter == screencast_capturers_.end()) { 1967 return; 1968 } 1969 VideoCapturer* capturer = iter->second; 1970 const VideoFormat* video_format = capturer->GetCaptureFormat(); 1971 data->fps = VideoFormat::IntervalToFps(video_format->interval); 1972 data->screencast_max_pixels = capturer->screencast_max_pixels(); 1973 } 1974 1975 void VideoChannel::OnScreencastWindowEvent_s(uint32 ssrc, 1976 rtc::WindowEvent we) { 1977 ASSERT(signaling_thread() == rtc::Thread::Current()); 1978 SignalScreencastWindowEvent(ssrc, we); 1979 } 1980 1981 bool VideoChannel::SetChannelOptions(const VideoOptions &options) { 1982 return InvokeOnWorker(Bind(&VideoMediaChannel::SetOptions, 1983 media_channel(), options)); 1984 } 1985 1986 void VideoChannel::OnMessage(rtc::Message *pmsg) { 1987 switch (pmsg->message_id) { 1988 case MSG_SCREENCASTWINDOWEVENT: { 1989 const ScreencastEventMessageData* data = 1990 static_cast<ScreencastEventMessageData*>(pmsg->pdata); 1991 OnScreencastWindowEvent_s(data->ssrc, data->event); 1992 delete data; 1993 break; 1994 } 1995 case MSG_CHANNEL_ERROR: { 1996 const VideoChannelErrorMessageData* data = 1997 static_cast<VideoChannelErrorMessageData*>(pmsg->pdata); 1998 SignalMediaError(this, data->ssrc, data->error); 1999 delete data; 2000 break; 2001 } 2002 default: 2003 BaseChannel::OnMessage(pmsg); 2004 break; 2005 } 2006 } 2007 2008 void VideoChannel::OnConnectionMonitorUpdate( 2009 SocketMonitor *monitor, const std::vector<ConnectionInfo> &infos) { 2010 SignalConnectionMonitor(this, infos); 2011 } 2012 2013 // TODO(pthatcher): Look into removing duplicate code between 2014 // audio, video, and data, perhaps by using templates. 2015 void VideoChannel::OnMediaMonitorUpdate( 2016 VideoMediaChannel* media_channel, const VideoMediaInfo &info) { 2017 ASSERT(media_channel == this->media_channel()); 2018 SignalMediaMonitor(this, info); 2019 } 2020 2021 void VideoChannel::OnScreencastWindowEvent(uint32 ssrc, 2022 rtc::WindowEvent event) { 2023 ScreencastEventMessageData* pdata = 2024 new ScreencastEventMessageData(ssrc, event); 2025 signaling_thread()->Post(this, MSG_SCREENCASTWINDOWEVENT, pdata); 2026 } 2027 2028 void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) { 2029 // Map capturer events to window events. In the future we may want to simply 2030 // pass these events up directly. 2031 rtc::WindowEvent we; 2032 if (ev == CS_STOPPED) { 2033 we = rtc::WE_CLOSE; 2034 } else if (ev == CS_PAUSED) { 2035 we = rtc::WE_MINIMIZE; 2036 } else if (ev == CS_RUNNING && previous_we_ == rtc::WE_MINIMIZE) { 2037 we = rtc::WE_RESTORE; 2038 } else { 2039 return; 2040 } 2041 previous_we_ = we; 2042 2043 uint32 ssrc = 0; 2044 if (!GetLocalSsrc(capturer, &ssrc)) { 2045 return; 2046 } 2047 2048 OnScreencastWindowEvent(ssrc, we); 2049 } 2050 2051 bool VideoChannel::GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc) { 2052 *ssrc = 0; 2053 for (ScreencastMap::iterator iter = screencast_capturers_.begin(); 2054 iter != screencast_capturers_.end(); ++iter) { 2055 if (iter->second == capturer) { 2056 *ssrc = iter->first; 2057 return true; 2058 } 2059 } 2060 return false; 2061 } 2062 2063 void VideoChannel::OnVideoChannelError(uint32 ssrc, 2064 VideoMediaChannel::Error error) { 2065 VideoChannelErrorMessageData* data = new VideoChannelErrorMessageData( 2066 ssrc, error); 2067 signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data); 2068 } 2069 2070 void VideoChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, 2071 SrtpFilter::Error error) { 2072 switch (error) { 2073 case SrtpFilter::ERROR_FAIL: 2074 OnVideoChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 2075 VideoMediaChannel::ERROR_REC_SRTP_ERROR : 2076 VideoMediaChannel::ERROR_PLAY_SRTP_ERROR); 2077 break; 2078 case SrtpFilter::ERROR_AUTH: 2079 OnVideoChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 2080 VideoMediaChannel::ERROR_REC_SRTP_AUTH_FAILED : 2081 VideoMediaChannel::ERROR_PLAY_SRTP_AUTH_FAILED); 2082 break; 2083 case SrtpFilter::ERROR_REPLAY: 2084 // Only receving channel should have this error. 2085 ASSERT(mode == SrtpFilter::UNPROTECT); 2086 // TODO(gangji): Turn on the signaling of replay error once we have 2087 // switched to the new mechanism for doing video retransmissions. 2088 // OnVideoChannelError(ssrc, VideoMediaChannel::ERROR_PLAY_SRTP_REPLAY); 2089 break; 2090 default: 2091 break; 2092 } 2093 } 2094 2095 2096 void VideoChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const { 2097 GetSupportedVideoCryptoSuites(ciphers); 2098 } 2099 2100 DataChannel::DataChannel(rtc::Thread* thread, 2101 DataMediaChannel* media_channel, 2102 BaseSession* session, 2103 const std::string& content_name, 2104 bool rtcp) 2105 // MediaEngine is NULL 2106 : BaseChannel(thread, NULL, media_channel, session, content_name, rtcp), 2107 data_channel_type_(cricket::DCT_NONE), 2108 ready_to_send_data_(false) { 2109 } 2110 2111 DataChannel::~DataChannel() { 2112 StopMediaMonitor(); 2113 // this can't be done in the base class, since it calls a virtual 2114 DisableMedia_w(); 2115 2116 Deinit(); 2117 } 2118 2119 bool DataChannel::Init() { 2120 TransportChannel* rtcp_channel = rtcp() ? session()->CreateChannel( 2121 content_name(), "data_rtcp", ICE_CANDIDATE_COMPONENT_RTCP) : NULL; 2122 if (!BaseChannel::Init(session()->CreateChannel( 2123 content_name(), "data_rtp", ICE_CANDIDATE_COMPONENT_RTP), 2124 rtcp_channel)) { 2125 return false; 2126 } 2127 media_channel()->SignalDataReceived.connect( 2128 this, &DataChannel::OnDataReceived); 2129 media_channel()->SignalMediaError.connect( 2130 this, &DataChannel::OnDataChannelError); 2131 media_channel()->SignalReadyToSend.connect( 2132 this, &DataChannel::OnDataChannelReadyToSend); 2133 media_channel()->SignalStreamClosedRemotely.connect( 2134 this, &DataChannel::OnStreamClosedRemotely); 2135 srtp_filter()->SignalSrtpError.connect( 2136 this, &DataChannel::OnSrtpError); 2137 return true; 2138 } 2139 2140 bool DataChannel::SendData(const SendDataParams& params, 2141 const rtc::Buffer& payload, 2142 SendDataResult* result) { 2143 return InvokeOnWorker(Bind(&DataMediaChannel::SendData, 2144 media_channel(), params, payload, result)); 2145 } 2146 2147 const ContentInfo* DataChannel::GetFirstContent( 2148 const SessionDescription* sdesc) { 2149 return GetFirstDataContent(sdesc); 2150 } 2151 2152 bool DataChannel::WantsPacket(bool rtcp, rtc::Buffer* packet) { 2153 if (data_channel_type_ == DCT_SCTP) { 2154 // TODO(pthatcher): Do this in a more robust way by checking for 2155 // SCTP or DTLS. 2156 return !IsRtpPacket(packet->data(), packet->length()); 2157 } else if (data_channel_type_ == DCT_RTP) { 2158 return BaseChannel::WantsPacket(rtcp, packet); 2159 } 2160 return false; 2161 } 2162 2163 bool DataChannel::SetDataChannelType(DataChannelType new_data_channel_type, 2164 std::string* error_desc) { 2165 // It hasn't been set before, so set it now. 2166 if (data_channel_type_ == DCT_NONE) { 2167 data_channel_type_ = new_data_channel_type; 2168 return true; 2169 } 2170 2171 // It's been set before, but doesn't match. That's bad. 2172 if (data_channel_type_ != new_data_channel_type) { 2173 std::ostringstream desc; 2174 desc << "Data channel type mismatch." 2175 << " Expected " << data_channel_type_ 2176 << " Got " << new_data_channel_type; 2177 SafeSetError(desc.str(), error_desc); 2178 return false; 2179 } 2180 2181 // It's hasn't changed. Nothing to do. 2182 return true; 2183 } 2184 2185 bool DataChannel::SetDataChannelTypeFromContent( 2186 const DataContentDescription* content, 2187 std::string* error_desc) { 2188 bool is_sctp = ((content->protocol() == kMediaProtocolSctp) || 2189 (content->protocol() == kMediaProtocolDtlsSctp)); 2190 DataChannelType data_channel_type = is_sctp ? DCT_SCTP : DCT_RTP; 2191 return SetDataChannelType(data_channel_type, error_desc); 2192 } 2193 2194 bool DataChannel::SetLocalContent_w(const MediaContentDescription* content, 2195 ContentAction action, 2196 std::string* error_desc) { 2197 ASSERT(worker_thread() == rtc::Thread::Current()); 2198 LOG(LS_INFO) << "Setting local data description"; 2199 2200 const DataContentDescription* data = 2201 static_cast<const DataContentDescription*>(content); 2202 ASSERT(data != NULL); 2203 if (!data) { 2204 SafeSetError("Can't find data content in local description.", error_desc); 2205 return false; 2206 } 2207 2208 bool ret = false; 2209 if (!SetDataChannelTypeFromContent(data, error_desc)) { 2210 return false; 2211 } 2212 2213 if (data_channel_type_ == DCT_SCTP) { 2214 // SCTP data channels don't need the rest of the stuff. 2215 ret = UpdateLocalStreams_w(data->streams(), action, error_desc); 2216 if (ret) { 2217 set_local_content_direction(content->direction()); 2218 // As in SetRemoteContent_w, make sure we set the local SCTP port 2219 // number as specified in our DataContentDescription. 2220 if (!media_channel()->SetRecvCodecs(data->codecs())) { 2221 SafeSetError("Failed to set data receive codecs.", error_desc); 2222 ret = false; 2223 } 2224 } 2225 } else { 2226 ret = SetBaseLocalContent_w(content, action, error_desc); 2227 if (action != CA_UPDATE || data->has_codecs()) { 2228 if (!media_channel()->SetRecvCodecs(data->codecs())) { 2229 SafeSetError("Failed to set data receive codecs.", error_desc); 2230 ret = false; 2231 } 2232 } 2233 } 2234 2235 // If everything worked, see if we can start receiving. 2236 if (ret) { 2237 std::vector<DataCodec>::const_iterator it = data->codecs().begin(); 2238 for (; it != data->codecs().end(); ++it) { 2239 bundle_filter()->AddPayloadType(it->id); 2240 } 2241 ChangeState(); 2242 } else { 2243 LOG(LS_WARNING) << "Failed to set local data description"; 2244 } 2245 return ret; 2246 } 2247 2248 bool DataChannel::SetRemoteContent_w(const MediaContentDescription* content, 2249 ContentAction action, 2250 std::string* error_desc) { 2251 ASSERT(worker_thread() == rtc::Thread::Current()); 2252 2253 const DataContentDescription* data = 2254 static_cast<const DataContentDescription*>(content); 2255 ASSERT(data != NULL); 2256 if (!data) { 2257 SafeSetError("Can't find data content in remote description.", error_desc); 2258 return false; 2259 } 2260 2261 bool ret = true; 2262 if (!SetDataChannelTypeFromContent(data, error_desc)) { 2263 return false; 2264 } 2265 2266 if (data_channel_type_ == DCT_SCTP) { 2267 LOG(LS_INFO) << "Setting SCTP remote data description"; 2268 // SCTP data channels don't need the rest of the stuff. 2269 ret = UpdateRemoteStreams_w(content->streams(), action, error_desc); 2270 if (ret) { 2271 set_remote_content_direction(content->direction()); 2272 // We send the SCTP port number (not to be confused with the underlying 2273 // UDP port number) as a codec parameter. Make sure it gets there. 2274 if (!media_channel()->SetSendCodecs(data->codecs())) { 2275 SafeSetError("Failed to set data send codecs.", error_desc); 2276 ret = false; 2277 } 2278 } 2279 } else { 2280 // If the remote data doesn't have codecs and isn't an update, it 2281 // must be empty, so ignore it. 2282 if (action != CA_UPDATE && !data->has_codecs()) { 2283 return true; 2284 } 2285 LOG(LS_INFO) << "Setting remote data description"; 2286 2287 // Set remote video codecs (what the other side wants to receive). 2288 if (action != CA_UPDATE || data->has_codecs()) { 2289 if (!media_channel()->SetSendCodecs(data->codecs())) { 2290 SafeSetError("Failed to set data send codecs.", error_desc); 2291 ret = false; 2292 } 2293 } 2294 2295 if (ret) { 2296 ret &= SetBaseRemoteContent_w(content, action, error_desc); 2297 } 2298 2299 if (action != CA_UPDATE) { 2300 int bandwidth_bps = data->bandwidth(); 2301 if (!media_channel()->SetMaxSendBandwidth(bandwidth_bps)) { 2302 std::ostringstream desc; 2303 desc << "Failed to set max send bandwidth for data content."; 2304 SafeSetError(desc.str(), error_desc); 2305 ret = false; 2306 } 2307 } 2308 } 2309 2310 // If everything worked, see if we can start sending. 2311 if (ret) { 2312 ChangeState(); 2313 } else { 2314 LOG(LS_WARNING) << "Failed to set remote data description"; 2315 } 2316 return ret; 2317 } 2318 2319 void DataChannel::ChangeState() { 2320 // Render incoming data if we're the active call, and we have the local 2321 // content. We receive data on the default channel and multiplexed streams. 2322 bool recv = IsReadyToReceive(); 2323 if (!media_channel()->SetReceive(recv)) { 2324 LOG(LS_ERROR) << "Failed to SetReceive on data channel"; 2325 } 2326 2327 // Send outgoing data if we're the active call, we have the remote content, 2328 // and we have had some form of connectivity. 2329 bool send = IsReadyToSend(); 2330 if (!media_channel()->SetSend(send)) { 2331 LOG(LS_ERROR) << "Failed to SetSend on data channel"; 2332 } 2333 2334 // Trigger SignalReadyToSendData asynchronously. 2335 OnDataChannelReadyToSend(send); 2336 2337 LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send; 2338 } 2339 2340 void DataChannel::OnMessage(rtc::Message *pmsg) { 2341 switch (pmsg->message_id) { 2342 case MSG_READYTOSENDDATA: { 2343 DataChannelReadyToSendMessageData* data = 2344 static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata); 2345 ready_to_send_data_ = data->data(); 2346 SignalReadyToSendData(ready_to_send_data_); 2347 delete data; 2348 break; 2349 } 2350 case MSG_DATARECEIVED: { 2351 DataReceivedMessageData* data = 2352 static_cast<DataReceivedMessageData*>(pmsg->pdata); 2353 SignalDataReceived(this, data->params, data->payload); 2354 delete data; 2355 break; 2356 } 2357 case MSG_CHANNEL_ERROR: { 2358 const DataChannelErrorMessageData* data = 2359 static_cast<DataChannelErrorMessageData*>(pmsg->pdata); 2360 SignalMediaError(this, data->ssrc, data->error); 2361 delete data; 2362 break; 2363 } 2364 case MSG_STREAMCLOSEDREMOTELY: { 2365 rtc::TypedMessageData<uint32>* data = 2366 static_cast<rtc::TypedMessageData<uint32>*>(pmsg->pdata); 2367 SignalStreamClosedRemotely(data->data()); 2368 delete data; 2369 break; 2370 } 2371 default: 2372 BaseChannel::OnMessage(pmsg); 2373 break; 2374 } 2375 } 2376 2377 void DataChannel::OnConnectionMonitorUpdate( 2378 SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos) { 2379 SignalConnectionMonitor(this, infos); 2380 } 2381 2382 void DataChannel::StartMediaMonitor(int cms) { 2383 media_monitor_.reset(new DataMediaMonitor(media_channel(), worker_thread(), 2384 rtc::Thread::Current())); 2385 media_monitor_->SignalUpdate.connect( 2386 this, &DataChannel::OnMediaMonitorUpdate); 2387 media_monitor_->Start(cms); 2388 } 2389 2390 void DataChannel::StopMediaMonitor() { 2391 if (media_monitor_) { 2392 media_monitor_->Stop(); 2393 media_monitor_->SignalUpdate.disconnect(this); 2394 media_monitor_.reset(); 2395 } 2396 } 2397 2398 void DataChannel::OnMediaMonitorUpdate( 2399 DataMediaChannel* media_channel, const DataMediaInfo& info) { 2400 ASSERT(media_channel == this->media_channel()); 2401 SignalMediaMonitor(this, info); 2402 } 2403 2404 void DataChannel::OnDataReceived( 2405 const ReceiveDataParams& params, const char* data, size_t len) { 2406 DataReceivedMessageData* msg = new DataReceivedMessageData( 2407 params, data, len); 2408 signaling_thread()->Post(this, MSG_DATARECEIVED, msg); 2409 } 2410 2411 void DataChannel::OnDataChannelError( 2412 uint32 ssrc, DataMediaChannel::Error err) { 2413 DataChannelErrorMessageData* data = new DataChannelErrorMessageData( 2414 ssrc, err); 2415 signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data); 2416 } 2417 2418 void DataChannel::OnDataChannelReadyToSend(bool writable) { 2419 // This is usded for congestion control to indicate that the stream is ready 2420 // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates 2421 // that the transport channel is ready. 2422 signaling_thread()->Post(this, MSG_READYTOSENDDATA, 2423 new DataChannelReadyToSendMessageData(writable)); 2424 } 2425 2426 void DataChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, 2427 SrtpFilter::Error error) { 2428 switch (error) { 2429 case SrtpFilter::ERROR_FAIL: 2430 OnDataChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 2431 DataMediaChannel::ERROR_SEND_SRTP_ERROR : 2432 DataMediaChannel::ERROR_RECV_SRTP_ERROR); 2433 break; 2434 case SrtpFilter::ERROR_AUTH: 2435 OnDataChannelError(ssrc, (mode == SrtpFilter::PROTECT) ? 2436 DataMediaChannel::ERROR_SEND_SRTP_AUTH_FAILED : 2437 DataMediaChannel::ERROR_RECV_SRTP_AUTH_FAILED); 2438 break; 2439 case SrtpFilter::ERROR_REPLAY: 2440 // Only receving channel should have this error. 2441 ASSERT(mode == SrtpFilter::UNPROTECT); 2442 OnDataChannelError(ssrc, DataMediaChannel::ERROR_RECV_SRTP_REPLAY); 2443 break; 2444 default: 2445 break; 2446 } 2447 } 2448 2449 void DataChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const { 2450 GetSupportedDataCryptoSuites(ciphers); 2451 } 2452 2453 bool DataChannel::ShouldSetupDtlsSrtp() const { 2454 return (data_channel_type_ == DCT_RTP); 2455 } 2456 2457 void DataChannel::OnStreamClosedRemotely(uint32 sid) { 2458 rtc::TypedMessageData<uint32>* message = 2459 new rtc::TypedMessageData<uint32>(sid); 2460 signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message); 2461 } 2462 2463 } // namespace cricket 2464