remoting/protocol/libjingle_transport_factory.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/protocol/libjingle_transport_factory.h"
   6
   7 #include "base/callback.h"
   8 #include "base/single_thread_task_runner.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "base/timer/timer.h"
  11 #include "jingle/glue/channel_socket_adapter.h"
  12 #include "jingle/glue/pseudotcp_adapter.h"
  13 #include "jingle/glue/thread_wrapper.h"
  14 #include "jingle/glue/utils.h"
  15 #include "net/base/net_errors.h"
  16 #include "remoting/base/constants.h"
  17 #include "remoting/jingle_glue/jingle_info_request.h"
  18 #include "remoting/jingle_glue/network_settings.h"
  19 #include "remoting/protocol/channel_authenticator.h"
  20 #include "third_party/libjingle/source/talk/base/network.h"
  21 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
  22 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
  23 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
  24 #include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
  25
  26 namespace remoting {
  27 namespace protocol {
  28
  29 namespace {
  30
  31 // Value is chosen to balance the extra latency against the reduced
  32 // load due to ACK traffic.
  33 const int kTcpAckDelayMilliseconds = 10;
  34
  35 // Values for the TCP send and receive buffer size. This should be tuned to
  36 // accommodate high latency network but not backlog the decoding pipeline.
  37 const int kTcpReceiveBufferSize = 256 * 1024;
  38 const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024;
  39
  40 // Try connecting ICE twice with timeout of 15 seconds for each attempt.
  41 const int kMaxReconnectAttempts = 2;
  42 const int kReconnectDelaySeconds = 15;
  43
  44 // Get fresh STUN/Relay configuration every hour.
  45 const int kJingleInfoUpdatePeriodSeconds = 3600;
  46
  47 class LibjingleStreamTransport
  48     : public StreamTransport,
  49       public base::SupportsWeakPtr<LibjingleStreamTransport>,
  50       public sigslot::has_slots<> {
  51  public:
  52   LibjingleStreamTransport(cricket::PortAllocator* port_allocator,
  53                            const NetworkSettings& network_settings);
  54   virtual ~LibjingleStreamTransport();
  55
  56   // Called by JingleTransportFactory when it has fresh Jingle info.
  57   void OnCanStart();
  58
  59   // StreamTransport interface.
  60   virtual void Initialize(
  61       const std::string& name,
  62       Transport::EventHandler* event_handler,
  63       scoped_ptr<ChannelAuthenticator> authenticator) OVERRIDE;
  64   virtual void Connect(
  65       const StreamTransport::ConnectedCallback& callback) OVERRIDE;
  66   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
  67   virtual const std::string& name() const OVERRIDE;
  68   virtual bool is_connected() const OVERRIDE;
  69
  70  private:
  71   void DoStart();
  72
  73   // Signal handlers for cricket::TransportChannel.
  74   void OnRequestSignaling(cricket::TransportChannelImpl* channel);
  75   void OnCandidateReady(cricket::TransportChannelImpl* channel,
  76                         const cricket::Candidate& candidate);
  77   void OnRouteChange(cricket::TransportChannel* channel,
  78                      const cricket::Candidate& candidate);
  79   void OnWritableState(cricket::TransportChannel* channel);
  80
  81   // Callback for PseudoTcpAdapter::Connect().
  82   void OnTcpConnected(int result);
  83
  84   // Callback for Authenticator::SecureAndAuthenticate();
  85   void OnAuthenticationDone(net::Error error,
  86                             scoped_ptr<net::StreamSocket> socket);
  87
  88   // Callback for jingle_glue::TransportChannelSocketAdapter to notify when the
  89   // socket is destroyed.
  90   void OnChannelDestroyed();
  91
  92   // Tries to connect by restarting ICE. Called by |reconnect_timer_|.
  93   void TryReconnect();
  94
  95   // Helper methods to call |callback_|.
  96   void NotifyConnected(scoped_ptr<net::StreamSocket> socket);
  97   void NotifyConnectFailed();
  98
  99   cricket::PortAllocator* port_allocator_;
 100   NetworkSettings network_settings_;
 101
 102   std::string name_;
 103   EventHandler* event_handler_;
 104   StreamTransport::ConnectedCallback callback_;
 105   scoped_ptr<ChannelAuthenticator> authenticator_;
 106   std::string ice_username_fragment_;
 107   std::string ice_password_;
 108
 109   bool can_start_;
 110
 111   std::list<cricket::Candidate> pending_candidates_;
 112   scoped_ptr<cricket::P2PTransportChannel> channel_;
 113   bool channel_was_writable_;
 114   int connect_attempts_left_;
 115   base::RepeatingTimer<LibjingleStreamTransport> reconnect_timer_;
 116
 117   // We own |socket_| until it is connected.
 118   scoped_ptr<jingle_glue::PseudoTcpAdapter> socket_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(LibjingleStreamTransport);
 121 };
 122
 123 LibjingleStreamTransport::LibjingleStreamTransport(
 124     cricket::PortAllocator* port_allocator,
 125     const NetworkSettings& network_settings)
 126     : port_allocator_(port_allocator),
 127       network_settings_(network_settings),
 128       event_handler_(NULL),
 129       ice_username_fragment_(
 130           talk_base::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
 131       ice_password_(talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH)),
 132       can_start_(false),
 133       channel_was_writable_(false),
 134       connect_attempts_left_(kMaxReconnectAttempts) {
 135 }
 136
 137 LibjingleStreamTransport::~LibjingleStreamTransport() {
 138   DCHECK(event_handler_);
 139   event_handler_->OnTransportDeleted(this);
 140   // Channel should be already destroyed if we were connected.
 141   DCHECK(!is_connected() || socket_.get() == NULL);
 142
 143   if (channel_.get()) {
 144     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
 145         FROM_HERE, channel_.release());
 146   }
 147 }
 148
 149 void LibjingleStreamTransport::OnCanStart() {
 150   DCHECK(CalledOnValidThread());
 151
 152   DCHECK(!can_start_);
 153   can_start_ = true;
 154
 155   // If Connect() has been called then start connection.
 156   if (!callback_.is_null())
 157     DoStart();
 158
 159   while (!pending_candidates_.empty()) {
 160     channel_->OnCandidate(pending_candidates_.front());
 161     pending_candidates_.pop_front();
 162   }
 163 }
 164
 165 void LibjingleStreamTransport::Initialize(
 166     const std::string& name,
 167     Transport::EventHandler* event_handler,
 168     scoped_ptr<ChannelAuthenticator> authenticator) {
 169   DCHECK(CalledOnValidThread());
 170
 171   DCHECK(!name.empty());
 172   DCHECK(event_handler);
 173
 174   // Can be initialized only once.
 175   DCHECK(name_.empty());
 176
 177   name_ = name;
 178   event_handler_ = event_handler;
 179   authenticator_ = authenticator.Pass();
 180 }
 181
 182 void LibjingleStreamTransport::Connect(
 183     const StreamTransport::ConnectedCallback& callback) {
 184   DCHECK(CalledOnValidThread());
 185   callback_ = callback;
 186
 187   if (can_start_)
 188     DoStart();
 189 }
 190
 191 void LibjingleStreamTransport::DoStart() {
 192   DCHECK(!channel_.get());
 193
 194   // Create P2PTransportChannel, attach signal handlers and connect it.
 195   // TODO(sergeyu): Specify correct component ID for the channel.
 196   channel_.reset(new cricket::P2PTransportChannel(
 197       std::string(), 0, NULL, port_allocator_));
 198   channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE);
 199   channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
 200   channel_->SignalRequestSignaling.connect(
 201       this, &LibjingleStreamTransport::OnRequestSignaling);
 202   channel_->SignalCandidateReady.connect(
 203       this, &LibjingleStreamTransport::OnCandidateReady);
 204   channel_->SignalRouteChange.connect(
 205       this, &LibjingleStreamTransport::OnRouteChange);
 206   channel_->SignalWritableState.connect(
 207       this, &LibjingleStreamTransport::OnWritableState);
 208   if (network_settings_.nat_traversal_mode ==
 209       NetworkSettings::NAT_TRAVERSAL_DISABLED) {
 210     channel_->set_incoming_only(true);
 211   }
 212
 213   channel_->Connect();
 214
 215   --connect_attempts_left_;
 216
 217   // Start reconnection timer.
 218   reconnect_timer_.Start(
 219       FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds),
 220       this, &LibjingleStreamTransport::TryReconnect);
 221
 222   // Create net::Socket adapter for the P2PTransportChannel.
 223   scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter(
 224       new jingle_glue::TransportChannelSocketAdapter(channel_.get()));
 225
 226   channel_adapter->SetOnDestroyedCallback(base::Bind(
 227       &LibjingleStreamTransport::OnChannelDestroyed, base::Unretained(this)));
 228
 229   // Configure and connect PseudoTCP adapter.
 230   socket_.reset(
 231       new jingle_glue::PseudoTcpAdapter(channel_adapter.release()));
 232   socket_->SetSendBufferSize(kTcpSendBufferSize);
 233   socket_->SetReceiveBufferSize(kTcpReceiveBufferSize);
 234   socket_->SetNoDelay(true);
 235   socket_->SetAckDelay(kTcpAckDelayMilliseconds);
 236
 237   // TODO(sergeyu): This is a hack to improve latency of the video
 238   // channel. Consider removing it once we have better flow control
 239   // implemented.
 240   if (name_ == kVideoChannelName)
 241     socket_->SetWriteWaitsForSend(true);
 242
 243   int result = socket_->Connect(
 244       base::Bind(&LibjingleStreamTransport::OnTcpConnected,
 245                  base::Unretained(this)));
 246   if (result != net::ERR_IO_PENDING)
 247     OnTcpConnected(result);
 248 }
 249
 250 void LibjingleStreamTransport::AddRemoteCandidate(
 251     const cricket::Candidate& candidate) {
 252   DCHECK(CalledOnValidThread());
 253   if (channel_) {
 254     channel_->OnCandidate(candidate);
 255   } else {
 256     pending_candidates_.push_back(candidate);
 257   }
 258 }
 259
 260 const std::string& LibjingleStreamTransport::name() const {
 261   DCHECK(CalledOnValidThread());
 262   return name_;
 263 }
 264
 265 bool LibjingleStreamTransport::is_connected() const {
 266   DCHECK(CalledOnValidThread());
 267   return callback_.is_null();
 268 }
 269
 270 void LibjingleStreamTransport::OnRequestSignaling(
 271     cricket::TransportChannelImpl* channel) {
 272   DCHECK(CalledOnValidThread());
 273   channel_->OnSignalingReady();
 274 }
 275
 276 void LibjingleStreamTransport::OnCandidateReady(
 277     cricket::TransportChannelImpl* channel,
 278     const cricket::Candidate& candidate) {
 279   DCHECK(CalledOnValidThread());
 280   event_handler_->OnTransportCandidate(this, candidate);
 281 }
 282
 283 void LibjingleStreamTransport::OnRouteChange(
 284     cricket::TransportChannel* channel,
 285     const cricket::Candidate& candidate) {
 286   TransportRoute route;
 287
 288   if (candidate.type() == "local") {
 289     route.type = TransportRoute::DIRECT;
 290   } else if (candidate.type() == "stun") {
 291     route.type = TransportRoute::STUN;
 292   } else if (candidate.type() == "relay") {
 293     route.type = TransportRoute::RELAY;
 294   } else {
 295     LOG(FATAL) << "Unknown candidate type: " << candidate.type();
 296   }
 297
 298   if (!jingle_glue::SocketAddressToIPEndPoint(
 299           candidate.address(), &route.remote_address)) {
 300     LOG(FATAL) << "Failed to convert peer IP address.";
 301   }
 302
 303   DCHECK(channel_->best_connection());
 304   const cricket::Candidate& local_candidate =
 305       channel_->best_connection()->local_candidate();
 306   if (!jingle_glue::SocketAddressToIPEndPoint(
 307           local_candidate.address(), &route.local_address)) {
 308     LOG(FATAL) << "Failed to convert local IP address.";
 309   }
 310
 311   event_handler_->OnTransportRouteChange(this, route);
 312 }
 313
 314 void LibjingleStreamTransport::OnWritableState(
 315     cricket::TransportChannel* channel) {
 316   DCHECK_EQ(channel, channel_.get());
 317
 318   event_handler_->OnTransportReady(this, channel->writable());
 319
 320   if (channel->writable()) {
 321     channel_was_writable_ = true;
 322     connect_attempts_left_ = kMaxReconnectAttempts;
 323     reconnect_timer_.Stop();
 324   } else if (!channel->writable() && channel_was_writable_) {
 325     reconnect_timer_.Reset();
 326     TryReconnect();
 327   }
 328 }
 329
 330 void LibjingleStreamTransport::OnTcpConnected(int result) {
 331   DCHECK(CalledOnValidThread());
 332
 333   if (result != net::OK) {
 334     NotifyConnectFailed();
 335     return;
 336   }
 337
 338   authenticator_->SecureAndAuthenticate(
 339       socket_.PassAs<net::StreamSocket>(),
 340       base::Bind(&LibjingleStreamTransport::OnAuthenticationDone,
 341                  base::Unretained(this)));
 342 }
 343
 344 void LibjingleStreamTransport::OnAuthenticationDone(
 345     net::Error error,
 346     scoped_ptr<net::StreamSocket> socket) {
 347   if (error != net::OK) {
 348     NotifyConnectFailed();
 349     return;
 350   }
 351
 352   NotifyConnected(socket.Pass());
 353 }
 354
 355 void LibjingleStreamTransport::OnChannelDestroyed() {
 356   if (is_connected()) {
 357     // The connection socket is being deleted, so delete the transport too.
 358     delete this;
 359   }
 360 }
 361
 362 void LibjingleStreamTransport::TryReconnect() {
 363   DCHECK(!channel_->writable());
 364
 365   if (connect_attempts_left_ <= 0) {
 366     reconnect_timer_.Stop();
 367
 368     // Notify the caller that ICE connection has failed - normally that will
 369     // terminate Jingle connection (i.e. the transport will be destroyed).
 370     event_handler_->OnTransportFailed(this);
 371     return;
 372   }
 373   --connect_attempts_left_;
 374
 375   // Restart ICE by resetting ICE password.
 376   ice_password_ = talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH);
 377   channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
 378 }
 379
 380 void LibjingleStreamTransport::NotifyConnected(
 381     scoped_ptr<net::StreamSocket> socket) {
 382   DCHECK(!is_connected());
 383   StreamTransport::ConnectedCallback callback = callback_;
 384   callback_.Reset();
 385   callback.Run(socket.Pass());
 386 }
 387
 388 void LibjingleStreamTransport::NotifyConnectFailed() {
 389   DCHECK(!is_connected());
 390
 391   socket_.reset();
 392
 393   // This method may be called in response to a libjingle signal, so
 394   // libjingle objects must be deleted asynchronously.
 395   if (channel_.get()) {
 396     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
 397         FROM_HERE, channel_.release());
 398   }
 399
 400   authenticator_.reset();
 401
 402   NotifyConnected(scoped_ptr<net::StreamSocket>());
 403 }
 404
 405 }  // namespace
 406
 407 LibjingleTransportFactory::LibjingleTransportFactory(
 408     SignalStrategy* signal_strategy,
 409     scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator,
 410     const NetworkSettings& network_settings)
 411     : signal_strategy_(signal_strategy),
 412       port_allocator_(port_allocator.Pass()),
 413       network_settings_(network_settings) {
 414   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 415 }
 416
 417 LibjingleTransportFactory::~LibjingleTransportFactory() {
 418   // This method may be called in response to a libjingle signal, so
 419   // libjingle objects must be deleted asynchronously.
 420   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
 421       base::ThreadTaskRunnerHandle::Get();
 422   task_runner->DeleteSoon(FROM_HERE, port_allocator_.release());
 423 }
 424
 425 void LibjingleTransportFactory::PrepareTokens() {
 426   EnsureFreshJingleInfo();
 427 }
 428
 429 scoped_ptr<StreamTransport> LibjingleTransportFactory::CreateStreamTransport() {
 430   scoped_ptr<LibjingleStreamTransport> result(
 431       new LibjingleStreamTransport(port_allocator_.get(), network_settings_));
 432
 433   EnsureFreshJingleInfo();
 434
 435   // If there is a pending |jingle_info_request_| delay starting the new
 436   // transport until the request is finished.
 437   if (jingle_info_request_) {
 438     on_jingle_info_callbacks_.push_back(
 439         base::Bind(&LibjingleStreamTransport::OnCanStart,
 440                    result->AsWeakPtr()));
 441   } else {
 442     result->OnCanStart();
 443   }
 444
 445   return result.PassAs<StreamTransport>();
 446 }
 447
 448 scoped_ptr<DatagramTransport>
 449 LibjingleTransportFactory::CreateDatagramTransport() {
 450   NOTIMPLEMENTED();
 451   return scoped_ptr<DatagramTransport>();
 452 }
 453
 454 void LibjingleTransportFactory::EnsureFreshJingleInfo() {
 455   if (network_settings_.nat_traversal_mode !=
 456           NetworkSettings::NAT_TRAVERSAL_ENABLED ||
 457       jingle_info_request_) {
 458     return;
 459   }
 460
 461   if (base::TimeTicks::Now() - last_jingle_info_update_time_ >
 462       base::TimeDelta::FromSeconds(kJingleInfoUpdatePeriodSeconds)) {
 463     jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
 464     jingle_info_request_->Send(base::Bind(
 465         &LibjingleTransportFactory::OnJingleInfo, base::Unretained(this)));
 466   }
 467 }
 468
 469 void LibjingleTransportFactory::OnJingleInfo(
 470     const std::string& relay_token,
 471     const std::vector<std::string>& relay_hosts,
 472     const std::vector<talk_base::SocketAddress>& stun_hosts) {
 473   if (!relay_token.empty() && !relay_hosts.empty()) {
 474     port_allocator_->SetRelayHosts(relay_hosts);
 475     port_allocator_->SetRelayToken(relay_token);
 476   }
 477   if (!stun_hosts.empty()) {
 478     port_allocator_->SetStunHosts(stun_hosts);
 479   }
 480
 481   jingle_info_request_.reset();
 482   if ((!relay_token.empty() && !relay_hosts.empty()) || !stun_hosts.empty())
 483     last_jingle_info_update_time_ = base::TimeTicks::Now();
 484
 485   while (!on_jingle_info_callbacks_.empty()) {
 486     on_jingle_info_callbacks_.begin()->Run();
 487     on_jingle_info_callbacks_.pop_front();
 488   }
 489 }
 490
 491 }  // namespace protocol
 492 }  // namespace remoting