src/third_party/libjingle/source/talk/app/webrtc/webrtcsession.h

   1 /*
   2  * libjingle
   3  * Copyright 2012, 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 #ifndef TALK_APP_WEBRTC_WEBRTCSESSION_H_
  29 #define TALK_APP_WEBRTC_WEBRTCSESSION_H_
  30
  31 #include <string>
  32
  33 #include "talk/app/webrtc/peerconnectioninterface.h"
  34 #include "talk/app/webrtc/dtmfsender.h"
  35 #include "talk/app/webrtc/mediastreamprovider.h"
  36 #include "talk/app/webrtc/datachannel.h"
  37 #include "talk/app/webrtc/statstypes.h"
  38 #include "talk/base/sigslot.h"
  39 #include "talk/base/thread.h"
  40 #include "talk/media/base/mediachannel.h"
  41 #include "talk/p2p/base/session.h"
  42 #include "talk/session/media/mediasession.h"
  43
  44 namespace cricket {
  45 class BaseChannel;
  46 class ChannelManager;
  47 class DataChannel;
  48 class StatsReport;
  49 class Transport;
  50 class VideoCapturer;
  51 class VideoChannel;
  52 class VoiceChannel;
  53 }  // namespace cricket
  54
  55 namespace webrtc {
  56 class IceRestartAnswerLatch;
  57 class MediaStreamSignaling;
  58 class WebRtcSessionDescriptionFactory;
  59
  60 extern const char kBundleWithoutRtcpMux[];
  61 extern const char kCreateChannelFailed[];
  62 extern const char kInvalidCandidates[];
  63 extern const char kInvalidSdp[];
  64 extern const char kMlineMismatch[];
  65 extern const char kPushDownTDFailed[];
  66 extern const char kSdpWithoutCrypto[];
  67 extern const char kSdpWithoutIceUfragPwd[];
  68 extern const char kSdpWithoutSdesAndDtlsDisabled[];
  69 extern const char kSessionError[];
  70 extern const char kSessionErrorDesc[];
  71
  72 // ICE state callback interface.
  73 class IceObserver {
  74  public:
  75   IceObserver() {}
  76   // Called any time the IceConnectionState changes
  77   virtual void OnIceConnectionChange(
  78       PeerConnectionInterface::IceConnectionState new_state) {}
  79   // Called any time the IceGatheringState changes
  80   virtual void OnIceGatheringChange(
  81       PeerConnectionInterface::IceGatheringState new_state) {}
  82   // New Ice candidate have been found.
  83   virtual void OnIceCandidate(const IceCandidateInterface* candidate) = 0;
  84   // All Ice candidates have been found.
  85   // TODO(bemasc): Remove this once callers transition to OnIceGatheringChange.
  86   // (via PeerConnectionObserver)
  87   virtual void OnIceComplete() {}
  88
  89  protected:
  90   ~IceObserver() {}
  91
  92  private:
  93   DISALLOW_COPY_AND_ASSIGN(IceObserver);
  94 };
  95
  96 class WebRtcSession : public cricket::BaseSession,
  97                       public AudioProviderInterface,
  98                       public DataChannelFactory,
  99                       public VideoProviderInterface,
 100                       public DtmfProviderInterface,
 101                       public DataChannelProviderInterface {
 102  public:
 103   WebRtcSession(cricket::ChannelManager* channel_manager,
 104                 talk_base::Thread* signaling_thread,
 105                 talk_base::Thread* worker_thread,
 106                 cricket::PortAllocator* port_allocator,
 107                 MediaStreamSignaling* mediastream_signaling);
 108   virtual ~WebRtcSession();
 109
 110   bool Initialize(const PeerConnectionFactoryInterface::Options& options,
 111                   const MediaConstraintsInterface* constraints,
 112                   DTLSIdentityServiceInterface* dtls_identity_service);
 113   // Deletes the voice, video and data channel and changes the session state
 114   // to STATE_RECEIVEDTERMINATE.
 115   void Terminate();
 116
 117   void RegisterIceObserver(IceObserver* observer) {
 118     ice_observer_ = observer;
 119   }
 120
 121   virtual cricket::VoiceChannel* voice_channel() {
 122     return voice_channel_.get();
 123   }
 124   virtual cricket::VideoChannel* video_channel() {
 125     return video_channel_.get();
 126   }
 127   virtual cricket::DataChannel* data_channel() {
 128     return data_channel_.get();
 129   }
 130
 131   void SetSecurePolicy(cricket::SecureMediaPolicy secure_policy);
 132   cricket::SecureMediaPolicy SecurePolicy() const;
 133
 134   // Get current ssl role from transport.
 135   bool GetSslRole(talk_base::SSLRole* role);
 136
 137   // Generic error message callback from WebRtcSession.
 138   // TODO - It may be necessary to supply error code as well.
 139   sigslot::signal0<> SignalError;
 140
 141   void CreateOffer(CreateSessionDescriptionObserver* observer,
 142                    const MediaConstraintsInterface* constraints);
 143   void CreateAnswer(CreateSessionDescriptionObserver* observer,
 144                     const MediaConstraintsInterface* constraints);
 145   // The ownership of |desc| will be transferred after this call.
 146   bool SetLocalDescription(SessionDescriptionInterface* desc,
 147                            std::string* err_desc);
 148   // The ownership of |desc| will be transferred after this call.
 149   bool SetRemoteDescription(SessionDescriptionInterface* desc,
 150                             std::string* err_desc);
 151   bool ProcessIceMessage(const IceCandidateInterface* ice_candidate);
 152   const SessionDescriptionInterface* local_description() const {
 153     return local_desc_.get();
 154   }
 155   const SessionDescriptionInterface* remote_description() const {
 156     return remote_desc_.get();
 157   }
 158
 159   // Get the id used as a media stream track's "id" field from ssrc.
 160   virtual bool GetTrackIdBySsrc(uint32 ssrc, std::string* id);
 161
 162   // AudioMediaProviderInterface implementation.
 163   virtual void SetAudioPlayout(uint32 ssrc, bool enable,
 164                                cricket::AudioRenderer* renderer) OVERRIDE;
 165   virtual void SetAudioSend(uint32 ssrc, bool enable,
 166                             const cricket::AudioOptions& options,
 167                             cricket::AudioRenderer* renderer) OVERRIDE;
 168
 169   // Implements VideoMediaProviderInterface.
 170   virtual bool SetCaptureDevice(uint32 ssrc,
 171                                 cricket::VideoCapturer* camera) OVERRIDE;
 172   virtual void SetVideoPlayout(uint32 ssrc,
 173                                bool enable,
 174                                cricket::VideoRenderer* renderer) OVERRIDE;
 175   virtual void SetVideoSend(uint32 ssrc, bool enable,
 176                             const cricket::VideoOptions* options) OVERRIDE;
 177
 178   // Implements DtmfProviderInterface.
 179   virtual bool CanInsertDtmf(const std::string& track_id);
 180   virtual bool InsertDtmf(const std::string& track_id,
 181                           int code, int duration);
 182   virtual sigslot::signal0<>* GetOnDestroyedSignal();
 183
 184   // Implements DataChannelProviderInterface.
 185   virtual bool SendData(const cricket::SendDataParams& params,
 186                         const talk_base::Buffer& payload,
 187                         cricket::SendDataResult* result) OVERRIDE;
 188   virtual bool ConnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE;
 189   virtual void DisconnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE;
 190   virtual void AddSctpDataStream(uint32 sid) OVERRIDE;
 191   virtual void RemoveSctpDataStream(uint32 sid) OVERRIDE;
 192   virtual bool ReadyToSendData() const OVERRIDE;
 193
 194   // Implements DataChannelFactory.
 195   talk_base::scoped_refptr<DataChannel> CreateDataChannel(
 196       const std::string& label,
 197       const InternalDataChannelInit* config) OVERRIDE;
 198
 199   cricket::DataChannelType data_channel_type() const;
 200
 201   bool IceRestartPending() const;
 202
 203   void ResetIceRestartLatch();
 204
 205   // Called when an SSLIdentity is generated or retrieved by
 206   // WebRTCSessionDescriptionFactory. Should happen before setLocalDescription.
 207   void OnIdentityReady(talk_base::SSLIdentity* identity);
 208
 209   // For unit test.
 210   bool waiting_for_identity() const;
 211
 212  private:
 213   // Indicates the type of SessionDescription in a call to SetLocalDescription
 214   // and SetRemoteDescription.
 215   enum Action {
 216     kOffer,
 217     kPrAnswer,
 218     kAnswer,
 219   };
 220
 221   // Invokes ConnectChannels() on transport proxies, which initiates ice
 222   // candidates allocation.
 223   bool StartCandidatesAllocation();
 224   bool UpdateSessionState(Action action, cricket::ContentSource source,
 225                           std::string* err_desc);
 226   static Action GetAction(const std::string& type);
 227
 228   // Transport related callbacks, override from cricket::BaseSession.
 229   virtual void OnTransportRequestSignaling(cricket::Transport* transport);
 230   virtual void OnTransportConnecting(cricket::Transport* transport);
 231   virtual void OnTransportWritable(cricket::Transport* transport);
 232   virtual void OnTransportProxyCandidatesReady(
 233       cricket::TransportProxy* proxy,
 234       const cricket::Candidates& candidates);
 235   virtual void OnCandidatesAllocationDone();
 236
 237   // Creates local session description with audio and video contents.
 238   bool CreateDefaultLocalDescription();
 239   // Enables media channels to allow sending of media.
 240   void EnableChannels();
 241   // Creates a JsepIceCandidate and adds it to the local session description
 242   // and notify observers. Called when a new local candidate have been found.
 243   void ProcessNewLocalCandidate(const std::string& content_name,
 244                                 const cricket::Candidates& candidates);
 245   // Returns the media index for a local ice candidate given the content name.
 246   // Returns false if the local session description does not have a media
 247   // content called  |content_name|.
 248   bool GetLocalCandidateMediaIndex(const std::string& content_name,
 249                                    int* sdp_mline_index);
 250   // Uses all remote candidates in |remote_desc| in this session.
 251   bool UseCandidatesInSessionDescription(
 252       const SessionDescriptionInterface* remote_desc);
 253   // Uses |candidate| in this session.
 254   bool UseCandidate(const IceCandidateInterface* candidate);
 255   // Deletes the corresponding channel of contents that don't exist in |desc|.
 256   // |desc| can be null. This means that all channels are deleted.
 257   void RemoveUnusedChannelsAndTransports(
 258       const cricket::SessionDescription* desc);
 259
 260   // Allocates media channels based on the |desc|. If |desc| doesn't have
 261   // the BUNDLE option, this method will disable BUNDLE in PortAllocator.
 262   // This method will also delete any existing media channels before creating.
 263   bool CreateChannels(const cricket::SessionDescription* desc);
 264
 265   // Helper methods to create media channels.
 266   bool CreateVoiceChannel(const cricket::ContentInfo* content);
 267   bool CreateVideoChannel(const cricket::ContentInfo* content);
 268   bool CreateDataChannel(const cricket::ContentInfo* content);
 269
 270   // Copy the candidates from |saved_candidates_| to |dest_desc|.
 271   // The |saved_candidates_| will be cleared after this function call.
 272   void CopySavedCandidates(SessionDescriptionInterface* dest_desc);
 273
 274   // Listens to SCTP CONTROL messages on unused SIDs and process them as OPEN
 275   // messages.
 276   void OnDataChannelMessageReceived(cricket::DataChannel* channel,
 277                                     const cricket::ReceiveDataParams& params,
 278                                     const talk_base::Buffer& payload);
 279
 280   bool GetLocalTrackId(uint32 ssrc, std::string* track_id);
 281   bool GetRemoteTrackId(uint32 ssrc, std::string* track_id);
 282
 283   std::string BadStateErrMsg(State state);
 284   void SetIceConnectionState(PeerConnectionInterface::IceConnectionState state);
 285
 286   bool ValidateBundleSettings(const cricket::SessionDescription* desc);
 287   bool HasRtcpMuxEnabled(const cricket::ContentInfo* content);
 288   // Below methods are helper methods which verifies SDP.
 289   bool ValidateSessionDescription(const SessionDescriptionInterface* sdesc,
 290                                   cricket::ContentSource source,
 291                                   std::string* err_desc);
 292
 293   // Check if a call to SetLocalDescription is acceptable with |action|.
 294   bool ExpectSetLocalDescription(Action action);
 295   // Check if a call to SetRemoteDescription is acceptable with |action|.
 296   bool ExpectSetRemoteDescription(Action action);
 297   // Verifies a=setup attribute as per RFC 5763.
 298   bool ValidateDtlsSetupAttribute(const cricket::SessionDescription* desc,
 299                                   Action action);
 300
 301   std::string GetSessionErrorMsg();
 302
 303   talk_base::scoped_ptr<cricket::VoiceChannel> voice_channel_;
 304   talk_base::scoped_ptr<cricket::VideoChannel> video_channel_;
 305   talk_base::scoped_ptr<cricket::DataChannel> data_channel_;
 306   cricket::ChannelManager* channel_manager_;
 307   MediaStreamSignaling* mediastream_signaling_;
 308   IceObserver* ice_observer_;
 309   PeerConnectionInterface::IceConnectionState ice_connection_state_;
 310   talk_base::scoped_ptr<SessionDescriptionInterface> local_desc_;
 311   talk_base::scoped_ptr<SessionDescriptionInterface> remote_desc_;
 312   // Candidates that arrived before the remote description was set.
 313   std::vector<IceCandidateInterface*> saved_candidates_;
 314   // If the remote peer is using a older version of implementation.
 315   bool older_version_remote_peer_;
 316   bool dtls_enabled_;
 317   // Flag will be set based on the constraint value.
 318   bool dscp_enabled_;
 319   // Specifies which kind of data channel is allowed. This is controlled
 320   // by the chrome command-line flag and constraints:
 321   // 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
 322   // constraint kEnableDtlsSrtp is true, and constaint kEnableRtpDataChannels is
 323   // not set or false, SCTP is allowed (DCT_SCTP);
 324   // 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
 325   // 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
 326   cricket::DataChannelType data_channel_type_;
 327   talk_base::scoped_ptr<IceRestartAnswerLatch> ice_restart_latch_;
 328
 329   talk_base::scoped_ptr<WebRtcSessionDescriptionFactory>
 330       webrtc_session_desc_factory_;
 331
 332   sigslot::signal0<> SignalVoiceChannelDestroyed;
 333   sigslot::signal0<> SignalVideoChannelDestroyed;
 334   sigslot::signal0<> SignalDataChannelDestroyed;
 335
 336   DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 337 };
 338 }  // namespace webrtc
 339
 340 #endif  // TALK_APP_WEBRTC_WEBRTCSESSION_H_