blob: 0f4f0a2ea6092236162ff8c7dfbfa5dcc8eb302b [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/protocol/jingle_session.h"
#include "base/bind.h"
#include "base/rand_util.h"
#include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "remoting/base/constants.h"
#include "remoting/protocol/authenticator.h"
#include "remoting/protocol/channel_authenticator.h"
#include "remoting/protocol/channel_multiplexer.h"
#include "remoting/protocol/content_description.h"
#include "remoting/protocol/jingle_messages.h"
#include "remoting/protocol/jingle_session_manager.h"
#include "remoting/protocol/pseudotcp_channel_factory.h"
#include "remoting/protocol/secure_channel_factory.h"
#include "remoting/protocol/session_config.h"
#include "remoting/protocol/stream_channel_factory.h"
#include "remoting/signaling/iq_sender.h"
#include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
#include "third_party/webrtc/p2p/base/candidate.h"
using buzz::XmlElement;
namespace remoting {
namespace protocol {
namespace {
// Delay after candidate creation before sending transport-info message to
// accumulate multiple candidates. This is an optimization to reduce number of
// transport-info messages.
const int kTransportInfoSendDelayMs = 20;
// How long we should wait for a response from the other end. This value is used
// for all requests except |transport-info|.
const int kDefaultMessageTimeout = 10;
// During a reconnection, it usually takes longer for the peer to respond due to
// pending messages in the channel from the previous session. From experiment,
// it can take up to 20s for the session to reconnect. To make it safe, setting
// the timeout to 30s.
const int kSessionInitiateAndAcceptTimeout = kDefaultMessageTimeout * 3;
// Timeout for the transport-info messages.
const int kTransportInfoTimeout = 10 * 60;
// Name of the multiplexed channel.
const char kMuxChannelName[] = "mux";
ErrorCode AuthRejectionReasonToErrorCode(
Authenticator::RejectionReason reason) {
switch (reason) {
case Authenticator::INVALID_CREDENTIALS:
return AUTHENTICATION_FAILED;
case Authenticator::PROTOCOL_ERROR:
return INCOMPATIBLE_PROTOCOL;
}
NOTREACHED();
return UNKNOWN_ERROR;
}
} // namespace
JingleSession::JingleSession(JingleSessionManager* session_manager)
: session_manager_(session_manager),
event_handler_(nullptr),
state_(INITIALIZING),
error_(OK),
weak_factory_(this) {
}
JingleSession::~JingleSession() {
channel_multiplexer_.reset();
STLDeleteContainerPointers(pending_requests_.begin(),
pending_requests_.end());
STLDeleteContainerPointers(transport_info_requests_.begin(),
transport_info_requests_.end());
DCHECK(channels_.empty());
session_manager_->SessionDestroyed(this);
}
void JingleSession::SetEventHandler(Session::EventHandler* event_handler) {
DCHECK(CalledOnValidThread());
DCHECK(event_handler);
event_handler_ = event_handler;
}
ErrorCode JingleSession::error() {
DCHECK(CalledOnValidThread());
return error_;
}
void JingleSession::StartConnection(
const std::string& peer_jid,
scoped_ptr<Authenticator> authenticator,
scoped_ptr<CandidateSessionConfig> config) {
DCHECK(CalledOnValidThread());
DCHECK(authenticator.get());
DCHECK_EQ(authenticator->state(), Authenticator::MESSAGE_READY);
peer_jid_ = peer_jid;
authenticator_ = authenticator.Pass();
candidate_config_ = config.Pass();
// Generate random session ID. There are usually not more than 1
// concurrent session per host, so a random 64-bit integer provides
// enough entropy. In the worst case connection will fail when two
// clients generate the same session ID concurrently.
session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
// Send session-initiate message.
JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
session_id_);
message.initiator = session_manager_->signal_strategy_->GetLocalJid();
message.description.reset(
new ContentDescription(candidate_config_->Clone(),
authenticator_->GetNextMessage()));
SendMessage(message);
SetState(CONNECTING);
}
void JingleSession::InitializeIncomingConnection(
const JingleMessage& initiate_message,
scoped_ptr<Authenticator> authenticator) {
DCHECK(CalledOnValidThread());
DCHECK(initiate_message.description.get());
DCHECK(authenticator.get());
DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
peer_jid_ = initiate_message.from;
authenticator_ = authenticator.Pass();
session_id_ = initiate_message.sid;
candidate_config_ = initiate_message.description->config()->Clone();
SetState(ACCEPTING);
}
void JingleSession::AcceptIncomingConnection(
const JingleMessage& initiate_message) {
DCHECK(config_);
// Process the first authentication message.
const buzz::XmlElement* first_auth_message =
initiate_message.description->authenticator_message();
if (!first_auth_message) {
CloseInternal(INCOMPATIBLE_PROTOCOL);
return;
}
DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
// |authenticator_| is owned, so Unretained() is safe here.
authenticator_->ProcessMessage(first_auth_message, base::Bind(
&JingleSession::ContinueAcceptIncomingConnection,
base::Unretained(this)));
}
void JingleSession::ContinueAcceptIncomingConnection() {
DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
if (authenticator_->state() == Authenticator::REJECTED) {
CloseInternal(AuthRejectionReasonToErrorCode(
authenticator_->rejection_reason()));
return;
}
// Send the session-accept message.
JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
session_id_);
scoped_ptr<buzz::XmlElement> auth_message;
if (authenticator_->state() == Authenticator::MESSAGE_READY)
auth_message = authenticator_->GetNextMessage();
message.description.reset(
new ContentDescription(CandidateSessionConfig::CreateFrom(*config_),
auth_message.Pass()));
SendMessage(message);
// Update state.
SetState(CONNECTED);
if (authenticator_->state() == Authenticator::ACCEPTED) {
OnAuthenticated();
} else {
DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
if (authenticator_->started()) {
SetState(AUTHENTICATING);
}
}
}
const std::string& JingleSession::jid() {
DCHECK(CalledOnValidThread());
return peer_jid_;
}
const CandidateSessionConfig* JingleSession::candidate_config() {
DCHECK(CalledOnValidThread());
return candidate_config_.get();
}
const SessionConfig& JingleSession::config() {
DCHECK(CalledOnValidThread());
return *config_;
}
void JingleSession::set_config(scoped_ptr<SessionConfig> config) {
DCHECK(CalledOnValidThread());
DCHECK(!config_);
config_ = config.Pass();
}
StreamChannelFactory* JingleSession::GetTransportChannelFactory() {
DCHECK(CalledOnValidThread());
return secure_channel_factory_.get();
}
StreamChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
DCHECK(CalledOnValidThread());
if (!channel_multiplexer_.get()) {
channel_multiplexer_.reset(
new ChannelMultiplexer(GetTransportChannelFactory(), kMuxChannelName));
}
return channel_multiplexer_.get();
}
void JingleSession::Close() {
DCHECK(CalledOnValidThread());
CloseInternal(OK);
}
void JingleSession::AddPendingRemoteTransportInfo(Transport* channel) {
std::list<JingleMessage::IceCredentials>::iterator credentials =
pending_remote_ice_credentials_.begin();
while (credentials != pending_remote_ice_credentials_.end()) {
if (credentials->channel == channel->name()) {
channel->SetRemoteCredentials(credentials->ufrag, credentials->password);
credentials = pending_remote_ice_credentials_.erase(credentials);
} else {
++credentials;
}
}
std::list<JingleMessage::NamedCandidate>::iterator candidate =
pending_remote_candidates_.begin();
while (candidate != pending_remote_candidates_.end()) {
if (candidate->name == channel->name()) {
channel->AddRemoteCandidate(candidate->candidate);
candidate = pending_remote_candidates_.erase(candidate);
} else {
++candidate;
}
}
}
void JingleSession::CreateChannel(const std::string& name,
const ChannelCreatedCallback& callback) {
DCHECK(!channels_[name]);
scoped_ptr<Transport> channel =
session_manager_->transport_factory_->CreateTransport();
channel->SetUseStandardIce(config_->standard_ice());
channel->Connect(name, this, callback);
AddPendingRemoteTransportInfo(channel.get());
channels_[name] = channel.release();
}
void JingleSession::CancelChannelCreation(const std::string& name) {
ChannelsMap::iterator it = channels_.find(name);
if (it != channels_.end()) {
DCHECK(!it->second->is_connected());
delete it->second;
DCHECK(channels_.find(name) == channels_.end());
}
}
void JingleSession::OnTransportIceCredentials(Transport* transport,
const std::string& ufrag,
const std::string& password) {
EnsurePendingTransportInfoMessage();
pending_transport_info_message_->ice_credentials.push_back(
JingleMessage::IceCredentials(transport->name(), ufrag, password));
}
void JingleSession::OnTransportCandidate(Transport* transport,
const cricket::Candidate& candidate) {
EnsurePendingTransportInfoMessage();
pending_transport_info_message_->candidates.push_back(
JingleMessage::NamedCandidate(transport->name(), candidate));
}
void JingleSession::OnTransportRouteChange(Transport* transport,
const TransportRoute& route) {
if (event_handler_)
event_handler_->OnSessionRouteChange(transport->name(), route);
}
void JingleSession::OnTransportFailed(Transport* transport) {
CloseInternal(CHANNEL_CONNECTION_ERROR);
}
void JingleSession::OnTransportDeleted(Transport* transport) {
ChannelsMap::iterator it = channels_.find(transport->name());
DCHECK_EQ(it->second, transport);
channels_.erase(it);
}
void JingleSession::SendMessage(const JingleMessage& message) {
scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
message.ToXml(),
base::Bind(&JingleSession::OnMessageResponse,
base::Unretained(this),
message.action));
int timeout = kDefaultMessageTimeout;
if (message.action == JingleMessage::SESSION_INITIATE ||
message.action == JingleMessage::SESSION_ACCEPT) {
timeout = kSessionInitiateAndAcceptTimeout;
}
if (request) {
request->SetTimeout(base::TimeDelta::FromSeconds(timeout));
pending_requests_.insert(request.release());
} else {
LOG(ERROR) << "Failed to send a "
<< JingleMessage::GetActionName(message.action) << " message";
}
}
void JingleSession::OnMessageResponse(
JingleMessage::ActionType request_type,
IqRequest* request,
const buzz::XmlElement* response) {
// Delete the request from the list of pending requests.
pending_requests_.erase(request);
delete request;
// Ignore all responses after session was closed.
if (state_ == CLOSED || state_ == FAILED)
return;
std::string type_str = JingleMessage::GetActionName(request_type);
// |response| will be nullptr if the request timed out.
if (!response) {
LOG(ERROR) << type_str << " request timed out.";
CloseInternal(SIGNALING_TIMEOUT);
return;
} else {
const std::string& type =
response->Attr(buzz::QName(std::string(), "type"));
if (type != "result") {
LOG(ERROR) << "Received error in response to " << type_str
<< " message: \"" << response->Str()
<< "\". Terminating the session.";
// TODO(sergeyu): There may be different reasons for error
// here. Parse the response stanza to find failure reason.
CloseInternal(PEER_IS_OFFLINE);
}
}
}
void JingleSession::EnsurePendingTransportInfoMessage() {
// |transport_info_timer_| must be running iff
// |pending_transport_info_message_| exists.
DCHECK_EQ(pending_transport_info_message_ != nullptr,
transport_info_timer_.IsRunning());
if (!pending_transport_info_message_) {
pending_transport_info_message_.reset(new JingleMessage(
peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_));
pending_transport_info_message_->standard_ice = config_->standard_ice();
// Delay sending the new candidates in case we get more candidates
// that we can send in one message.
transport_info_timer_.Start(
FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
this, &JingleSession::SendTransportInfo);
}
}
void JingleSession::SendTransportInfo() {
DCHECK(pending_transport_info_message_);
scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
pending_transport_info_message_->ToXml(),
base::Bind(&JingleSession::OnTransportInfoResponse,
base::Unretained(this)));
pending_transport_info_message_.reset();
if (request) {
request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
transport_info_requests_.push_back(request.release());
} else {
LOG(ERROR) << "Failed to send a transport-info message";
}
}
void JingleSession::OnTransportInfoResponse(IqRequest* request,
const buzz::XmlElement* response) {
DCHECK(!transport_info_requests_.empty());
// Consider transport-info requests sent before this one lost and delete
// corresponding IqRequest objects.
while (transport_info_requests_.front() != request) {
delete transport_info_requests_.front();
transport_info_requests_.pop_front();
}
// Delete the |request| itself.
DCHECK_EQ(request, transport_info_requests_.front());
delete request;
transport_info_requests_.pop_front();
// Ignore transport-info timeouts.
if (!response) {
LOG(ERROR) << "transport-info request has timed out.";
return;
}
const std::string& type = response->Attr(buzz::QName(std::string(), "type"));
if (type != "result") {
LOG(ERROR) << "Received error in response to transport-info message: \""
<< response->Str() << "\". Terminating the session.";
CloseInternal(PEER_IS_OFFLINE);
}
}
void JingleSession::OnIncomingMessage(const JingleMessage& message,
const ReplyCallback& reply_callback) {
DCHECK(CalledOnValidThread());
if (message.from != peer_jid_) {
// Ignore messages received from a different Jid.
reply_callback.Run(JingleMessageReply::INVALID_SID);
return;
}
switch (message.action) {
case JingleMessage::SESSION_ACCEPT:
OnAccept(message, reply_callback);
break;
case JingleMessage::SESSION_INFO:
OnSessionInfo(message, reply_callback);
break;
case JingleMessage::TRANSPORT_INFO:
reply_callback.Run(JingleMessageReply::NONE);
ProcessTransportInfo(message);
break;
case JingleMessage::SESSION_TERMINATE:
OnTerminate(message, reply_callback);
break;
default:
reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
}
}
void JingleSession::OnAccept(const JingleMessage& message,
const ReplyCallback& reply_callback) {
if (state_ != CONNECTING) {
reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
return;
}
reply_callback.Run(JingleMessageReply::NONE);
const buzz::XmlElement* auth_message =
message.description->authenticator_message();
if (!auth_message) {
DLOG(WARNING) << "Received session-accept without authentication message ";
CloseInternal(INCOMPATIBLE_PROTOCOL);
return;
}
if (!InitializeConfigFromDescription(message.description.get())) {
CloseInternal(INCOMPATIBLE_PROTOCOL);
return;
}
SetState(CONNECTED);
DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
authenticator_->ProcessMessage(auth_message, base::Bind(
&JingleSession::ProcessAuthenticationStep,base::Unretained(this)));
}
void JingleSession::OnSessionInfo(const JingleMessage& message,
const ReplyCallback& reply_callback) {
if (!message.info.get() ||
!Authenticator::IsAuthenticatorMessage(message.info.get())) {
reply_callback.Run(JingleMessageReply::UNSUPPORTED_INFO);
return;
}
if ((state_ != CONNECTED && state_ != AUTHENTICATING) ||
authenticator_->state() != Authenticator::WAITING_MESSAGE) {
LOG(WARNING) << "Received unexpected authenticator message "
<< message.info->Str();
reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
CloseInternal(INCOMPATIBLE_PROTOCOL);
return;
}
reply_callback.Run(JingleMessageReply::NONE);
authenticator_->ProcessMessage(message.info.get(), base::Bind(
&JingleSession::ProcessAuthenticationStep, base::Unretained(this)));
}
void JingleSession::ProcessTransportInfo(const JingleMessage& message) {
// Check if the transport information version matches what was negotiated.
if (message.standard_ice != config_->standard_ice()) {
LOG(ERROR) << "Received transport-info message in format different from "
"negotiated.";
CloseInternal(INCOMPATIBLE_PROTOCOL);
return;
}
for (std::list<JingleMessage::IceCredentials>::const_iterator it =
message.ice_credentials.begin();
it != message.ice_credentials.end(); ++it) {
ChannelsMap::iterator channel = channels_.find(it->channel);
if (channel != channels_.end()) {
channel->second->SetRemoteCredentials(it->ufrag, it->password);
} else {
// Transport info was received before the channel was created.
// This could happen due to messages being reordered on the wire.
pending_remote_ice_credentials_.push_back(*it);
}
}
for (std::list<JingleMessage::NamedCandidate>::const_iterator it =
message.candidates.begin();
it != message.candidates.end(); ++it) {
ChannelsMap::iterator channel = channels_.find(it->name);
if (channel != channels_.end()) {
channel->second->AddRemoteCandidate(it->candidate);
} else {
// Transport info was received before the channel was created.
// This could happen due to messages being reordered on the wire.
pending_remote_candidates_.push_back(*it);
}
}
}
void JingleSession::OnTerminate(const JingleMessage& message,
const ReplyCallback& reply_callback) {
if (!is_session_active()) {
LOG(WARNING) << "Received unexpected session-terminate message.";
reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
return;
}
reply_callback.Run(JingleMessageReply::NONE);
switch (message.reason) {
case JingleMessage::SUCCESS:
if (state_ == CONNECTING) {
error_ = SESSION_REJECTED;
} else {
error_ = OK;
}
break;
case JingleMessage::DECLINE:
error_ = AUTHENTICATION_FAILED;
break;
case JingleMessage::CANCEL:
error_ = HOST_OVERLOAD;
break;
case JingleMessage::GENERAL_ERROR:
error_ = CHANNEL_CONNECTION_ERROR;
break;
case JingleMessage::INCOMPATIBLE_PARAMETERS:
error_ = INCOMPATIBLE_PROTOCOL;
break;
default:
error_ = UNKNOWN_ERROR;
}
if (error_ != OK) {
SetState(FAILED);
} else {
SetState(CLOSED);
}
}
bool JingleSession::InitializeConfigFromDescription(
const ContentDescription* description) {
DCHECK(description);
config_ = SessionConfig::GetFinalConfig(description->config());
if (!config_) {
LOG(ERROR) << "session-accept does not specify configuration";
return false;
}
if (!candidate_config()->IsSupported(*config_)) {
LOG(ERROR) << "session-accept specifies an invalid configuration";
return false;
}
return true;
}
void JingleSession::ProcessAuthenticationStep() {
DCHECK(CalledOnValidThread());
DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
if (state_ != CONNECTED && state_ != AUTHENTICATING) {
DCHECK(state_ == FAILED || state_ == CLOSED);
// The remote host closed the connection while the authentication was being
// processed asynchronously, nothing to do.
return;
}
if (authenticator_->state() == Authenticator::MESSAGE_READY) {
JingleMessage message(peer_jid_, JingleMessage::SESSION_INFO, session_id_);
message.info = authenticator_->GetNextMessage();
DCHECK(message.info.get());
SendMessage(message);
}
DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
// The current JingleSession object can be destroyed by event_handler of
// SetState(AUTHENTICATING) and cause subsequent dereferencing of the this
// pointer to crash. To protect against it, we run ContinueAuthenticationStep
// asychronously using a weak pointer.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::Bind(&JingleSession::ContinueAuthenticationStep,
weak_factory_.GetWeakPtr()));
if (authenticator_->started()) {
SetState(AUTHENTICATING);
}
}
void JingleSession::ContinueAuthenticationStep() {
if (authenticator_->state() == Authenticator::ACCEPTED) {
OnAuthenticated();
} else if (authenticator_->state() == Authenticator::REJECTED) {
CloseInternal(AuthRejectionReasonToErrorCode(
authenticator_->rejection_reason()));
}
}
void JingleSession::OnAuthenticated() {
pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
secure_channel_factory_.reset(
new SecureChannelFactory(pseudotcp_channel_factory_.get(),
authenticator_.get()));
SetState(AUTHENTICATED);
}
void JingleSession::CloseInternal(ErrorCode error) {
DCHECK(CalledOnValidThread());
if (is_session_active()) {
// Send session-terminate message with the appropriate error code.
JingleMessage::Reason reason;
switch (error) {
case OK:
reason = JingleMessage::SUCCESS;
break;
case SESSION_REJECTED:
case AUTHENTICATION_FAILED:
reason = JingleMessage::DECLINE;
break;
case INCOMPATIBLE_PROTOCOL:
reason = JingleMessage::INCOMPATIBLE_PARAMETERS;
break;
case HOST_OVERLOAD:
reason = JingleMessage::CANCEL;
break;
default:
reason = JingleMessage::GENERAL_ERROR;
}
JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
session_id_);
message.reason = reason;
SendMessage(message);
}
error_ = error;
if (state_ != FAILED && state_ != CLOSED) {
if (error != OK) {
SetState(FAILED);
} else {
SetState(CLOSED);
}
}
}
void JingleSession::SetState(State new_state) {
DCHECK(CalledOnValidThread());
if (new_state != state_) {
DCHECK_NE(state_, CLOSED);
DCHECK_NE(state_, FAILED);
state_ = new_state;
if (event_handler_)
event_handler_->OnSessionStateChange(new_state);
}
}
bool JingleSession::is_session_active() {
return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
state_ == AUTHENTICATING || state_ == AUTHENTICATED;
}
} // namespace protocol
} // namespace remoting