remoting/protocol/jingle_session_manager.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_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "remoting/protocol/authenticator.h"
   9 #include "remoting/protocol/content_description.h"
  10 #include "remoting/protocol/jingle_messages.h"
  11 #include "remoting/protocol/jingle_session.h"
  12 #include "remoting/protocol/transport.h"
  13 #include "remoting/signaling/iq_sender.h"
  14 #include "remoting/signaling/signal_strategy.h"
  15 #include "third_party/webrtc/base/socketaddress.h"
  16 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
  17
  18 using buzz::QName;
  19
  20 namespace remoting {
  21 namespace protocol {
  22
  23 JingleSessionManager::JingleSessionManager(
  24     scoped_ptr<TransportFactory> transport_factory)
  25     : protocol_config_(CandidateSessionConfig::CreateDefault()),
  26       transport_factory_(transport_factory.Pass()),
  27       signal_strategy_(nullptr),
  28       listener_(nullptr),
  29       ready_(false) {}
  30
  31 JingleSessionManager::~JingleSessionManager() {
  32   Close();
  33 }
  34
  35 void JingleSessionManager::Init(
  36     SignalStrategy* signal_strategy,
  37     SessionManager::Listener* listener) {
  38   listener_ = listener;
  39   signal_strategy_ = signal_strategy;
  40   iq_sender_.reset(new IqSender(signal_strategy_));
  41
  42   signal_strategy_->AddListener(this);
  43
  44   OnSignalStrategyStateChange(signal_strategy_->GetState());
  45 }
  46
  47 void JingleSessionManager::set_protocol_config(
  48     scoped_ptr<CandidateSessionConfig> config) {
  49   protocol_config_ = config.Pass();
  50 }
  51
  52 scoped_ptr<Session> JingleSessionManager::Connect(
  53     const std::string& host_jid,
  54     scoped_ptr<Authenticator> authenticator) {
  55   // Notify |transport_factory_| that it may be used soon.
  56   transport_factory_->PrepareTokens();
  57
  58   scoped_ptr<JingleSession> session(new JingleSession(this));
  59   session->StartConnection(host_jid, authenticator.Pass());
  60   sessions_[session->session_id_] = session.get();
  61   return session.Pass();
  62 }
  63
  64 void JingleSessionManager::Close() {
  65   DCHECK(CalledOnValidThread());
  66
  67   // Close() can be called only after all sessions are destroyed.
  68   DCHECK(sessions_.empty());
  69
  70   listener_ = nullptr;
  71
  72   if (signal_strategy_) {
  73     signal_strategy_->RemoveListener(this);
  74     signal_strategy_ = nullptr;
  75   }
  76 }
  77
  78 void JingleSessionManager::set_authenticator_factory(
  79     scoped_ptr<AuthenticatorFactory> authenticator_factory) {
  80   DCHECK(CalledOnValidThread());
  81   authenticator_factory_ = authenticator_factory.Pass();
  82 }
  83
  84 void JingleSessionManager::OnSignalStrategyStateChange(
  85     SignalStrategy::State state) {
  86   if (state == SignalStrategy::CONNECTED && !ready_) {
  87     ready_ = true;
  88     listener_->OnSessionManagerReady();
  89   }
  90 }
  91
  92 bool JingleSessionManager::OnSignalStrategyIncomingStanza(
  93     const buzz::XmlElement* stanza) {
  94   if (!JingleMessage::IsJingleMessage(stanza))
  95     return false;
  96
  97   JingleMessage message;
  98   std::string error;
  99   if (!message.ParseXml(stanza, &error)) {
 100     SendReply(stanza, JingleMessageReply::BAD_REQUEST);
 101     return true;
 102   }
 103
 104   if (message.action == JingleMessage::SESSION_INITIATE) {
 105     // Description must be present in session-initiate messages.
 106     DCHECK(message.description.get());
 107
 108     SendReply(stanza, JingleMessageReply::NONE);
 109
 110     // Notify |transport_factory_| that it may be used soon.
 111     transport_factory_->PrepareTokens();
 112
 113     scoped_ptr<Authenticator> authenticator =
 114         authenticator_factory_->CreateAuthenticator(
 115             signal_strategy_->GetLocalJid(), message.from,
 116             message.description->authenticator_message());
 117
 118     JingleSession* session = new JingleSession(this);
 119     session->InitializeIncomingConnection(message, authenticator.Pass());
 120     sessions_[session->session_id_] = session;
 121
 122     // Destroy the session if it was rejected due to incompatible protocol.
 123     if (session->state_ != Session::ACCEPTING) {
 124       delete session;
 125       DCHECK(sessions_.find(message.sid) == sessions_.end());
 126       return true;
 127     }
 128
 129     IncomingSessionResponse response = SessionManager::DECLINE;
 130     listener_->OnIncomingSession(session, &response);
 131
 132     if (response == SessionManager::ACCEPT) {
 133       session->AcceptIncomingConnection(message);
 134     } else {
 135       ErrorCode error;
 136       switch (response) {
 137         case OVERLOAD:
 138           error = HOST_OVERLOAD;
 139           break;
 140
 141         case DECLINE:
 142           error = SESSION_REJECTED;
 143           break;
 144
 145         default:
 146           NOTREACHED();
 147           error = SESSION_REJECTED;
 148       }
 149
 150       session->CloseInternal(error);
 151       delete session;
 152       DCHECK(sessions_.find(message.sid) == sessions_.end());
 153     }
 154
 155     return true;
 156   }
 157
 158   SessionsMap::iterator it = sessions_.find(message.sid);
 159   if (it == sessions_.end()) {
 160     SendReply(stanza, JingleMessageReply::INVALID_SID);
 161     return true;
 162   }
 163
 164   it->second->OnIncomingMessage(message, base::Bind(
 165       &JingleSessionManager::SendReply, base::Unretained(this), stanza));
 166   return true;
 167 }
 168
 169 void JingleSessionManager::SendReply(const buzz::XmlElement* original_stanza,
 170                                      JingleMessageReply::ErrorType error) {
 171   signal_strategy_->SendStanza(
 172       JingleMessageReply(error).ToXml(original_stanza));
 173 }
 174
 175 void JingleSessionManager::SessionDestroyed(JingleSession* session) {
 176   sessions_.erase(session->session_id_);
 177 }
 178
 179 }  // namespace protocol
 180 }  // namespace remoting