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