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