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/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 SetIceTransports(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_
    366