remoting/protocol/jingle_session.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/jingle_session.h"
   6
   7 #include "base/bind.h"
   8 #include "base/rand_util.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/stl_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/thread_task_runner_handle.h"
  13 #include "base/time/time.h"
  14 #include "remoting/base/constants.h"
  15 #include "remoting/protocol/authenticator.h"
  16 #include "remoting/protocol/channel_authenticator.h"
  17 #include "remoting/protocol/channel_multiplexer.h"
  18 #include "remoting/protocol/content_description.h"
  19 #include "remoting/protocol/jingle_messages.h"
  20 #include "remoting/protocol/jingle_session_manager.h"
  21 #include "remoting/protocol/pseudotcp_channel_factory.h"
  22 #include "remoting/protocol/secure_channel_factory.h"
  23 #include "remoting/protocol/session_config.h"
  24 #include "remoting/protocol/stream_channel_factory.h"
  25 #include "remoting/signaling/iq_sender.h"
  26 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
  27 #include "third_party/webrtc/p2p/base/candidate.h"
  28
  29 using buzz::XmlElement;
  30
  31 namespace remoting {
  32 namespace protocol {
  33
  34 namespace {
  35 // Delay after candidate creation before sending transport-info
  36 // message. This is neccessary to be able to pack multiple candidates
  37 // into one transport-info messages. The value needs to be greater
  38 // than zero because ports are opened asynchronously in the browser
  39 // process.
  40 const int kTransportInfoSendDelayMs = 2;
  41
  42 // How long we should wait for a response from the other end. This value is used
  43 // for all requests except |transport-info|.
  44 const int kDefaultMessageTimeout = 10;
  45
  46 // During a reconnection, it usually takes longer for the peer to respond due to
  47 // pending messages in the channel from the previous session.  From experiment,
  48 // it can take up to 20s for the session to reconnect. To make it safe, setting
  49 // the timeout to 30s.
  50 const int kSessionInitiateAndAcceptTimeout = kDefaultMessageTimeout * 3;
  51
  52 // Timeout for the transport-info messages.
  53 const int kTransportInfoTimeout = 10 * 60;
  54
  55 // Name of the multiplexed channel.
  56 const char kMuxChannelName[] = "mux";
  57
  58 ErrorCode AuthRejectionReasonToErrorCode(
  59     Authenticator::RejectionReason reason) {
  60   switch (reason) {
  61     case Authenticator::INVALID_CREDENTIALS:
  62       return AUTHENTICATION_FAILED;
  63     case Authenticator::PROTOCOL_ERROR:
  64       return INCOMPATIBLE_PROTOCOL;
  65   }
  66   NOTREACHED();
  67   return UNKNOWN_ERROR;
  68 }
  69
  70 }  // namespace
  71
  72 JingleSession::JingleSession(JingleSessionManager* session_manager)
  73     : session_manager_(session_manager),
  74       event_handler_(nullptr),
  75       state_(INITIALIZING),
  76       error_(OK),
  77       config_is_set_(false),
  78       weak_factory_(this) {
  79 }
  80
  81 JingleSession::~JingleSession() {
  82   channel_multiplexer_.reset();
  83   STLDeleteContainerPointers(pending_requests_.begin(),
  84                              pending_requests_.end());
  85   STLDeleteContainerPointers(transport_info_requests_.begin(),
  86                              transport_info_requests_.end());
  87
  88   DCHECK(channels_.empty());
  89
  90   session_manager_->SessionDestroyed(this);
  91 }
  92
  93 void JingleSession::SetEventHandler(Session::EventHandler* event_handler) {
  94   DCHECK(CalledOnValidThread());
  95   DCHECK(event_handler);
  96   event_handler_ = event_handler;
  97 }
  98
  99 ErrorCode JingleSession::error() {
 100   DCHECK(CalledOnValidThread());
 101   return error_;
 102 }
 103
 104 void JingleSession::StartConnection(
 105     const std::string& peer_jid,
 106     scoped_ptr<Authenticator> authenticator,
 107     scoped_ptr<CandidateSessionConfig> config) {
 108   DCHECK(CalledOnValidThread());
 109   DCHECK(authenticator.get());
 110   DCHECK_EQ(authenticator->state(), Authenticator::MESSAGE_READY);
 111
 112   peer_jid_ = peer_jid;
 113   authenticator_ = authenticator.Pass();
 114   candidate_config_ = config.Pass();
 115
 116   // Generate random session ID. There are usually not more than 1
 117   // concurrent session per host, so a random 64-bit integer provides
 118   // enough entropy. In the worst case connection will fail when two
 119   // clients generate the same session ID concurrently.
 120   session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
 121
 122   // Send session-initiate message.
 123   JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
 124                         session_id_);
 125   message.initiator = session_manager_->signal_strategy_->GetLocalJid();
 126   message.description.reset(
 127       new ContentDescription(candidate_config_->Clone(),
 128                              authenticator_->GetNextMessage()));
 129   SendMessage(message);
 130
 131   SetState(CONNECTING);
 132 }
 133
 134 void JingleSession::InitializeIncomingConnection(
 135     const JingleMessage& initiate_message,
 136     scoped_ptr<Authenticator> authenticator) {
 137   DCHECK(CalledOnValidThread());
 138   DCHECK(initiate_message.description.get());
 139   DCHECK(authenticator.get());
 140   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 141
 142   peer_jid_ = initiate_message.from;
 143   authenticator_ = authenticator.Pass();
 144   session_id_ = initiate_message.sid;
 145   candidate_config_ = initiate_message.description->config()->Clone();
 146
 147   SetState(ACCEPTING);
 148 }
 149
 150 void JingleSession::AcceptIncomingConnection(
 151     const JingleMessage& initiate_message) {
 152   DCHECK(config_is_set_);
 153
 154   // Process the first authentication message.
 155   const buzz::XmlElement* first_auth_message =
 156       initiate_message.description->authenticator_message();
 157
 158   if (!first_auth_message) {
 159     CloseInternal(INCOMPATIBLE_PROTOCOL);
 160     return;
 161   }
 162
 163   DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
 164   // |authenticator_| is owned, so Unretained() is safe here.
 165   authenticator_->ProcessMessage(first_auth_message, base::Bind(
 166       &JingleSession::ContinueAcceptIncomingConnection,
 167       base::Unretained(this)));
 168 }
 169
 170 void JingleSession::ContinueAcceptIncomingConnection() {
 171   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
 172   if (authenticator_->state() == Authenticator::REJECTED) {
 173     CloseInternal(AuthRejectionReasonToErrorCode(
 174         authenticator_->rejection_reason()));
 175     return;
 176   }
 177
 178   // Send the session-accept message.
 179   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
 180                         session_id_);
 181
 182   scoped_ptr<buzz::XmlElement> auth_message;
 183   if (authenticator_->state() == Authenticator::MESSAGE_READY)
 184     auth_message = authenticator_->GetNextMessage();
 185
 186   message.description.reset(
 187       new ContentDescription(CandidateSessionConfig::CreateFrom(config_),
 188                              auth_message.Pass()));
 189   SendMessage(message);
 190
 191   // Update state.
 192   SetState(CONNECTED);
 193
 194   if (authenticator_->state() == Authenticator::ACCEPTED) {
 195     OnAuthenticated();
 196   } else {
 197     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
 198     if (authenticator_->started()) {
 199       SetState(AUTHENTICATING);
 200     }
 201   }
 202 }
 203
 204 const std::string& JingleSession::jid() {
 205   DCHECK(CalledOnValidThread());
 206   return peer_jid_;
 207 }
 208
 209 const CandidateSessionConfig* JingleSession::candidate_config() {
 210   DCHECK(CalledOnValidThread());
 211   return candidate_config_.get();
 212 }
 213
 214 const SessionConfig& JingleSession::config() {
 215   DCHECK(CalledOnValidThread());
 216   return config_;
 217 }
 218
 219 void JingleSession::set_config(const SessionConfig& config) {
 220   DCHECK(CalledOnValidThread());
 221   DCHECK(!config_is_set_);
 222   config_ = config;
 223   config_is_set_ = true;
 224 }
 225
 226 StreamChannelFactory* JingleSession::GetTransportChannelFactory() {
 227   DCHECK(CalledOnValidThread());
 228   return secure_channel_factory_.get();
 229 }
 230
 231 StreamChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
 232   DCHECK(CalledOnValidThread());
 233   if (!channel_multiplexer_.get()) {
 234     channel_multiplexer_.reset(
 235         new ChannelMultiplexer(GetTransportChannelFactory(), kMuxChannelName));
 236   }
 237   return channel_multiplexer_.get();
 238 }
 239
 240 void JingleSession::Close() {
 241   DCHECK(CalledOnValidThread());
 242
 243   CloseInternal(OK);
 244 }
 245
 246 void JingleSession::AddPendingRemoteCandidates(Transport* channel,
 247                                                const std::string& name) {
 248   std::list<JingleMessage::NamedCandidate>::iterator it =
 249       pending_remote_candidates_.begin();
 250   while(it != pending_remote_candidates_.end()) {
 251     if (it->name == name) {
 252       channel->AddRemoteCandidate(it->candidate);
 253       it = pending_remote_candidates_.erase(it);
 254     } else {
 255       ++it;
 256     }
 257   }
 258 }
 259
 260 void JingleSession::CreateChannel(const std::string& name,
 261                                   const ChannelCreatedCallback& callback) {
 262   DCHECK(!channels_[name]);
 263
 264   scoped_ptr<Transport> channel =
 265       session_manager_->transport_factory_->CreateTransport();
 266   channel->Connect(name, this, callback);
 267   AddPendingRemoteCandidates(channel.get(), name);
 268   channels_[name] = channel.release();
 269 }
 270
 271 void JingleSession::CancelChannelCreation(const std::string& name) {
 272   ChannelsMap::iterator it = channels_.find(name);
 273   if (it != channels_.end()) {
 274     DCHECK(!it->second->is_connected());
 275     delete it->second;
 276     DCHECK(channels_.find(name) == channels_.end());
 277   }
 278 }
 279
 280 void JingleSession::OnTransportCandidate(Transport* transport,
 281                                          const cricket::Candidate& candidate) {
 282   pending_candidates_.push_back(JingleMessage::NamedCandidate(
 283       transport->name(), candidate));
 284
 285   if (!transport_infos_timer_.IsRunning()) {
 286     // Delay sending the new candidates in case we get more candidates
 287     // that we can send in one message.
 288     transport_infos_timer_.Start(
 289         FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
 290         this, &JingleSession::SendTransportInfo);
 291   }
 292 }
 293
 294 void JingleSession::OnTransportRouteChange(Transport* transport,
 295                                            const TransportRoute& route) {
 296   if (event_handler_)
 297     event_handler_->OnSessionRouteChange(transport->name(), route);
 298 }
 299
 300 void JingleSession::OnTransportFailed(Transport* transport) {
 301   CloseInternal(CHANNEL_CONNECTION_ERROR);
 302 }
 303
 304 void JingleSession::OnTransportDeleted(Transport* transport) {
 305   ChannelsMap::iterator it = channels_.find(transport->name());
 306   DCHECK_EQ(it->second, transport);
 307   channels_.erase(it);
 308 }
 309
 310 void JingleSession::SendMessage(const JingleMessage& message) {
 311   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
 312       message.ToXml(),
 313       base::Bind(&JingleSession::OnMessageResponse,
 314                  base::Unretained(this),
 315                  message.action));
 316
 317   int timeout = kDefaultMessageTimeout;
 318   if (message.action == JingleMessage::SESSION_INITIATE ||
 319       message.action == JingleMessage::SESSION_ACCEPT) {
 320     timeout = kSessionInitiateAndAcceptTimeout;
 321   }
 322   if (request) {
 323     request->SetTimeout(base::TimeDelta::FromSeconds(timeout));
 324     pending_requests_.insert(request.release());
 325   } else {
 326     LOG(ERROR) << "Failed to send a "
 327                << JingleMessage::GetActionName(message.action) << " message";
 328   }
 329 }
 330
 331 void JingleSession::OnMessageResponse(
 332     JingleMessage::ActionType request_type,
 333     IqRequest* request,
 334     const buzz::XmlElement* response) {
 335   // Delete the request from the list of pending requests.
 336   pending_requests_.erase(request);
 337   delete request;
 338
 339   // Ignore all responses after session was closed.
 340   if (state_ == CLOSED || state_ == FAILED)
 341     return;
 342
 343   std::string type_str = JingleMessage::GetActionName(request_type);
 344
 345   // |response| will be nullptr if the request timed out.
 346   if (!response) {
 347     LOG(ERROR) << type_str << " request timed out.";
 348     CloseInternal(SIGNALING_TIMEOUT);
 349     return;
 350   } else {
 351     const std::string& type =
 352         response->Attr(buzz::QName(std::string(), "type"));
 353     if (type != "result") {
 354       LOG(ERROR) << "Received error in response to " << type_str
 355                  << " message: \"" << response->Str()
 356                  << "\". Terminating the session.";
 357
 358       // TODO(sergeyu): There may be different reasons for error
 359       // here. Parse the response stanza to find failure reason.
 360       CloseInternal(PEER_IS_OFFLINE);
 361     }
 362   }
 363 }
 364
 365 void JingleSession::SendTransportInfo() {
 366   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
 367   message.candidates.swap(pending_candidates_);
 368
 369   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
 370       message.ToXml(),
 371       base::Bind(&JingleSession::OnTransportInfoResponse,
 372                  base::Unretained(this)));
 373   if (request) {
 374     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
 375     transport_info_requests_.push_back(request.release());
 376   } else {
 377     LOG(ERROR) << "Failed to send a transport-info message";
 378   }
 379 }
 380
 381 void JingleSession::OnTransportInfoResponse(IqRequest* request,
 382                                             const buzz::XmlElement* response) {
 383   DCHECK(!transport_info_requests_.empty());
 384
 385   // Consider transport-info requests sent before this one lost and delete
 386   // corresponding IqRequest objects.
 387   while (transport_info_requests_.front() != request) {
 388     delete transport_info_requests_.front();
 389     transport_info_requests_.pop_front();
 390   }
 391
 392   // Delete the |request| itself.
 393   DCHECK_EQ(request, transport_info_requests_.front());
 394   delete request;
 395   transport_info_requests_.pop_front();
 396
 397   // Ignore transport-info timeouts.
 398   if (!response) {
 399     LOG(ERROR) << "transport-info request has timed out.";
 400     return;
 401   }
 402
 403   const std::string& type = response->Attr(buzz::QName(std::string(), "type"));
 404   if (type != "result") {
 405     LOG(ERROR) << "Received error in response to transport-info message: \""
 406                << response->Str() << "\". Terminating the session.";
 407     CloseInternal(PEER_IS_OFFLINE);
 408   }
 409 }
 410
 411 void JingleSession::OnIncomingMessage(const JingleMessage& message,
 412                                       const ReplyCallback& reply_callback) {
 413   DCHECK(CalledOnValidThread());
 414
 415   if (message.from != peer_jid_) {
 416     // Ignore messages received from a different Jid.
 417     reply_callback.Run(JingleMessageReply::INVALID_SID);
 418     return;
 419   }
 420
 421   switch (message.action) {
 422     case JingleMessage::SESSION_ACCEPT:
 423       OnAccept(message, reply_callback);
 424       break;
 425
 426     case JingleMessage::SESSION_INFO:
 427       OnSessionInfo(message, reply_callback);
 428       break;
 429
 430     case JingleMessage::TRANSPORT_INFO:
 431       reply_callback.Run(JingleMessageReply::NONE);
 432       ProcessTransportInfo(message);
 433       break;
 434
 435     case JingleMessage::SESSION_TERMINATE:
 436       OnTerminate(message, reply_callback);
 437       break;
 438
 439     default:
 440       reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
 441   }
 442 }
 443
 444 void JingleSession::OnAccept(const JingleMessage& message,
 445                              const ReplyCallback& reply_callback) {
 446   if (state_ != CONNECTING) {
 447     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
 448     return;
 449   }
 450
 451   reply_callback.Run(JingleMessageReply::NONE);
 452
 453   const buzz::XmlElement* auth_message =
 454       message.description->authenticator_message();
 455   if (!auth_message) {
 456     DLOG(WARNING) << "Received session-accept without authentication message ";
 457     CloseInternal(INCOMPATIBLE_PROTOCOL);
 458     return;
 459   }
 460
 461   if (!InitializeConfigFromDescription(message.description.get())) {
 462     CloseInternal(INCOMPATIBLE_PROTOCOL);
 463     return;
 464   }
 465
 466   // In case there is transport information in the accept message.
 467   ProcessTransportInfo(message);
 468
 469   SetState(CONNECTED);
 470
 471   DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
 472   authenticator_->ProcessMessage(auth_message, base::Bind(
 473       &JingleSession::ProcessAuthenticationStep,base::Unretained(this)));
 474 }
 475
 476 void JingleSession::OnSessionInfo(const JingleMessage& message,
 477                                   const ReplyCallback& reply_callback) {
 478   if (!message.info.get() ||
 479       !Authenticator::IsAuthenticatorMessage(message.info.get())) {
 480     reply_callback.Run(JingleMessageReply::UNSUPPORTED_INFO);
 481     return;
 482   }
 483
 484   if ((state_ != CONNECTED && state_ != AUTHENTICATING) ||
 485       authenticator_->state() != Authenticator::WAITING_MESSAGE) {
 486     LOG(WARNING) << "Received unexpected authenticator message "
 487                  << message.info->Str();
 488     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
 489     CloseInternal(INCOMPATIBLE_PROTOCOL);
 490     return;
 491   }
 492
 493   reply_callback.Run(JingleMessageReply::NONE);
 494
 495   authenticator_->ProcessMessage(message.info.get(), base::Bind(
 496       &JingleSession::ProcessAuthenticationStep, base::Unretained(this)));
 497 }
 498
 499 void JingleSession::ProcessTransportInfo(const JingleMessage& message) {
 500   for (std::list<JingleMessage::NamedCandidate>::const_iterator it =
 501            message.candidates.begin();
 502        it != message.candidates.end(); ++it) {
 503     ChannelsMap::iterator channel = channels_.find(it->name);
 504     if (channel != channels_.end()) {
 505       channel->second->AddRemoteCandidate(it->candidate);
 506     } else {
 507       // Transport info was received before the channel was created.
 508       // This could happen due to messages being reordered on the wire.
 509       pending_remote_candidates_.push_back(*it);
 510     }
 511   }
 512 }
 513
 514 void JingleSession::OnTerminate(const JingleMessage& message,
 515                                 const ReplyCallback& reply_callback) {
 516   if (!is_session_active()) {
 517     LOG(WARNING) << "Received unexpected session-terminate message.";
 518     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
 519     return;
 520   }
 521
 522   reply_callback.Run(JingleMessageReply::NONE);
 523
 524   switch (message.reason) {
 525     case JingleMessage::SUCCESS:
 526       if (state_ == CONNECTING) {
 527         error_ = SESSION_REJECTED;
 528       } else {
 529         error_ = OK;
 530       }
 531       break;
 532     case JingleMessage::DECLINE:
 533       error_ = AUTHENTICATION_FAILED;
 534       break;
 535     case JingleMessage::CANCEL:
 536       error_ = HOST_OVERLOAD;
 537       break;
 538     case JingleMessage::GENERAL_ERROR:
 539       error_ = CHANNEL_CONNECTION_ERROR;
 540       break;
 541     case JingleMessage::INCOMPATIBLE_PARAMETERS:
 542       error_ = INCOMPATIBLE_PROTOCOL;
 543       break;
 544     default:
 545       error_ = UNKNOWN_ERROR;
 546   }
 547
 548   if (error_ != OK) {
 549     SetState(FAILED);
 550   } else {
 551     SetState(CLOSED);
 552   }
 553 }
 554
 555 bool JingleSession::InitializeConfigFromDescription(
 556     const ContentDescription* description) {
 557   DCHECK(description);
 558
 559   if (!description->config()->GetFinalConfig(&config_)) {
 560     LOG(ERROR) << "session-accept does not specify configuration";
 561     return false;
 562   }
 563   if (!candidate_config()->IsSupported(config_)) {
 564     LOG(ERROR) << "session-accept specifies an invalid configuration";
 565     return false;
 566   }
 567
 568   return true;
 569 }
 570
 571 void JingleSession::ProcessAuthenticationStep() {
 572   DCHECK(CalledOnValidThread());
 573   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
 574
 575   if (state_ != CONNECTED && state_ != AUTHENTICATING) {
 576     DCHECK(state_ == FAILED || state_ == CLOSED);
 577     // The remote host closed the connection while the authentication was being
 578     // processed asynchronously, nothing to do.
 579     return;
 580   }
 581
 582   if (authenticator_->state() == Authenticator::MESSAGE_READY) {
 583     JingleMessage message(peer_jid_, JingleMessage::SESSION_INFO, session_id_);
 584     message.info = authenticator_->GetNextMessage();
 585     DCHECK(message.info.get());
 586     SendMessage(message);
 587   }
 588   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 589
 590   // The current JingleSession object can be destroyed by event_handler of
 591   // SetState(AUTHENTICATING) and cause subsequent dereferencing of the this
 592   // pointer to crash.  To protect against it, we run ContinueAuthenticationStep
 593   // asychronously using a weak pointer.
 594   base::ThreadTaskRunnerHandle::Get()->PostTask(
 595     FROM_HERE,
 596     base::Bind(&JingleSession::ContinueAuthenticationStep,
 597                weak_factory_.GetWeakPtr()));
 598
 599   if (authenticator_->started()) {
 600     SetState(AUTHENTICATING);
 601   }
 602 }
 603
 604 void JingleSession::ContinueAuthenticationStep() {
 605   if (authenticator_->state() == Authenticator::ACCEPTED) {
 606     OnAuthenticated();
 607   } else if (authenticator_->state() == Authenticator::REJECTED) {
 608     CloseInternal(AuthRejectionReasonToErrorCode(
 609         authenticator_->rejection_reason()));
 610   }
 611 }
 612
 613 void JingleSession::OnAuthenticated() {
 614   pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
 615   secure_channel_factory_.reset(
 616       new SecureChannelFactory(pseudotcp_channel_factory_.get(),
 617                                authenticator_.get()));
 618
 619   SetState(AUTHENTICATED);
 620 }
 621
 622 void JingleSession::CloseInternal(ErrorCode error) {
 623   DCHECK(CalledOnValidThread());
 624
 625   if (is_session_active()) {
 626     // Send session-terminate message with the appropriate error code.
 627     JingleMessage::Reason reason;
 628     switch (error) {
 629       case OK:
 630         reason = JingleMessage::SUCCESS;
 631         break;
 632       case SESSION_REJECTED:
 633       case AUTHENTICATION_FAILED:
 634         reason = JingleMessage::DECLINE;
 635         break;
 636       case INCOMPATIBLE_PROTOCOL:
 637         reason = JingleMessage::INCOMPATIBLE_PARAMETERS;
 638         break;
 639       case HOST_OVERLOAD:
 640         reason = JingleMessage::CANCEL;
 641         break;
 642       default:
 643         reason = JingleMessage::GENERAL_ERROR;
 644     }
 645
 646     JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
 647                           session_id_);
 648     message.reason = reason;
 649     SendMessage(message);
 650   }
 651
 652   error_ = error;
 653
 654   if (state_ != FAILED && state_ != CLOSED) {
 655     if (error != OK) {
 656       SetState(FAILED);
 657     } else {
 658       SetState(CLOSED);
 659     }
 660   }
 661 }
 662
 663 void JingleSession::SetState(State new_state) {
 664   DCHECK(CalledOnValidThread());
 665
 666   if (new_state != state_) {
 667     DCHECK_NE(state_, CLOSED);
 668     DCHECK_NE(state_, FAILED);
 669
 670     state_ = new_state;
 671     if (event_handler_)
 672       event_handler_->OnSessionStateChange(new_state);
 673   }
 674 }
 675
 676 bool JingleSession::is_session_active() {
 677   return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
 678         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 679 }
 680
 681 }  // namespace protocol
 682 }  // namespace remoting