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_DATACHANNEL_H_ 29 #define TALK_APP_WEBRTC_DATACHANNEL_H_ 30 31 #include <deque> 32 #include <set> 33 #include <string> 34 35 #include "talk/app/webrtc/datachannelinterface.h" 36 #include "talk/app/webrtc/proxy.h" 37 #include "talk/media/base/mediachannel.h" 38 #include "talk/session/media/channel.h" 39 #include "webrtc/base/messagehandler.h" 40 #include "webrtc/base/scoped_ref_ptr.h" 41 #include "webrtc/base/sigslot.h" 42 43 namespace webrtc { 44 45 class DataChannel; 46 47 class DataChannelProviderInterface { 48 public: 49 // Sends the data to the transport. 50 virtual bool SendData(const cricket::SendDataParams& params, 51 const rtc::Buffer& payload, 52 cricket::SendDataResult* result) = 0; 53 // Connects to the transport signals. 54 virtual bool ConnectDataChannel(DataChannel* data_channel) = 0; 55 // Disconnects from the transport signals. 56 virtual void DisconnectDataChannel(DataChannel* data_channel) = 0; 57 // Adds the data channel SID to the transport for SCTP. 58 virtual void AddSctpDataStream(int sid) = 0; 59 // Removes the data channel SID from the transport for SCTP. 60 virtual void RemoveSctpDataStream(int sid) = 0; 61 // Returns true if the transport channel is ready to send data. 62 virtual bool ReadyToSendData() const = 0; 63 64 protected: ~DataChannelProviderInterface()65 virtual ~DataChannelProviderInterface() {} 66 }; 67 68 struct InternalDataChannelInit : public DataChannelInit { 69 enum OpenHandshakeRole { 70 kOpener, 71 kAcker, 72 kNone 73 }; 74 // The default role is kOpener because the default |negotiated| is false. InternalDataChannelInitInternalDataChannelInit75 InternalDataChannelInit() : open_handshake_role(kOpener) {} InternalDataChannelInitInternalDataChannelInit76 explicit InternalDataChannelInit(const DataChannelInit& base) 77 : DataChannelInit(base), open_handshake_role(kOpener) { 78 // If the channel is externally negotiated, do not send the OPEN message. 79 if (base.negotiated) { 80 open_handshake_role = kNone; 81 } 82 } 83 84 OpenHandshakeRole open_handshake_role; 85 }; 86 87 // Helper class to allocate unique IDs for SCTP DataChannels 88 class SctpSidAllocator { 89 public: 90 // Gets the first unused odd/even id based on the DTLS role. If |role| is 91 // SSL_CLIENT, the allocated id starts from 0 and takes even numbers; 92 // otherwise, the id starts from 1 and takes odd numbers. 93 // Returns false if no id can be allocated. 94 bool AllocateSid(rtc::SSLRole role, int* sid); 95 96 // Attempts to reserve a specific sid. Returns false if it's unavailable. 97 bool ReserveSid(int sid); 98 99 // Indicates that |sid| isn't in use any more, and is thus available again. 100 void ReleaseSid(int sid); 101 102 private: 103 // Checks if |sid| is available to be assigned to a new SCTP data channel. 104 bool IsSidAvailable(int sid) const; 105 106 std::set<int> used_sids_; 107 }; 108 109 // DataChannel is a an implementation of the DataChannelInterface based on 110 // libjingle's data engine. It provides an implementation of unreliable or 111 // reliabledata channels. Currently this class is specifically designed to use 112 // both RtpDataEngine and SctpDataEngine. 113 114 // DataChannel states: 115 // kConnecting: The channel has been created the transport might not yet be 116 // ready. 117 // kOpen: The channel have a local SSRC set by a call to UpdateSendSsrc 118 // and a remote SSRC set by call to UpdateReceiveSsrc and the transport 119 // has been writable once. 120 // kClosing: DataChannelInterface::Close has been called or UpdateReceiveSsrc 121 // has been called with SSRC==0 122 // kClosed: Both UpdateReceiveSsrc and UpdateSendSsrc has been called with 123 // SSRC==0. 124 class DataChannel : public DataChannelInterface, 125 public sigslot::has_slots<>, 126 public rtc::MessageHandler { 127 public: 128 static rtc::scoped_refptr<DataChannel> Create( 129 DataChannelProviderInterface* provider, 130 cricket::DataChannelType dct, 131 const std::string& label, 132 const InternalDataChannelInit& config); 133 134 virtual void RegisterObserver(DataChannelObserver* observer); 135 virtual void UnregisterObserver(); 136 label()137 virtual std::string label() const { return label_; } 138 virtual bool reliable() const; ordered()139 virtual bool ordered() const { return config_.ordered; } maxRetransmitTime()140 virtual uint16_t maxRetransmitTime() const { 141 return config_.maxRetransmitTime; 142 } maxRetransmits()143 virtual uint16_t maxRetransmits() const { return config_.maxRetransmits; } protocol()144 virtual std::string protocol() const { return config_.protocol; } negotiated()145 virtual bool negotiated() const { return config_.negotiated; } id()146 virtual int id() const { return config_.id; } 147 virtual uint64_t buffered_amount() const; 148 virtual void Close(); state()149 virtual DataState state() const { return state_; } 150 virtual bool Send(const DataBuffer& buffer); 151 152 // rtc::MessageHandler override. 153 virtual void OnMessage(rtc::Message* msg); 154 155 // Called when the channel's ready to use. That can happen when the 156 // underlying DataMediaChannel becomes ready, or when this channel is a new 157 // stream on an existing DataMediaChannel, and we've finished negotiation. 158 void OnChannelReady(bool writable); 159 160 // Sigslots from cricket::DataChannel 161 void OnDataReceived(cricket::DataChannel* channel, 162 const cricket::ReceiveDataParams& params, 163 const rtc::Buffer& payload); 164 void OnStreamClosedRemotely(uint32_t sid); 165 166 // The remote peer request that this channel should be closed. 167 void RemotePeerRequestClose(); 168 169 // The following methods are for SCTP only. 170 171 // Sets the SCTP sid and adds to transport layer if not set yet. Should only 172 // be called once. 173 void SetSctpSid(int sid); 174 // Called when the transport channel is created. 175 // Only needs to be called for SCTP data channels. 176 void OnTransportChannelCreated(); 177 // Called when the transport channel is destroyed. 178 void OnTransportChannelDestroyed(); 179 180 // The following methods are for RTP only. 181 182 // Set the SSRC this channel should use to send data on the 183 // underlying data engine. |send_ssrc| == 0 means that the channel is no 184 // longer part of the session negotiation. 185 void SetSendSsrc(uint32_t send_ssrc); 186 // Set the SSRC this channel should use to receive data from the 187 // underlying data engine. 188 void SetReceiveSsrc(uint32_t receive_ssrc); 189 data_channel_type()190 cricket::DataChannelType data_channel_type() const { 191 return data_channel_type_; 192 } 193 194 // Emitted when state transitions to kClosed. 195 // In the case of SCTP channels, this signal can be used to tell when the 196 // channel's sid is free. 197 sigslot::signal1<DataChannel*> SignalClosed; 198 199 protected: 200 DataChannel(DataChannelProviderInterface* client, 201 cricket::DataChannelType dct, 202 const std::string& label); 203 virtual ~DataChannel(); 204 205 private: 206 // A packet queue which tracks the total queued bytes. Queued packets are 207 // owned by this class. 208 class PacketQueue { 209 public: 210 PacketQueue(); 211 ~PacketQueue(); 212 byte_count()213 size_t byte_count() const { 214 return byte_count_; 215 } 216 217 bool Empty() const; 218 219 DataBuffer* Front(); 220 221 void Pop(); 222 223 void Push(DataBuffer* packet); 224 225 void Clear(); 226 227 void Swap(PacketQueue* other); 228 229 private: 230 std::deque<DataBuffer*> packets_; 231 size_t byte_count_; 232 }; 233 234 // The OPEN(_ACK) signaling state. 235 enum HandshakeState { 236 kHandshakeInit, 237 kHandshakeShouldSendOpen, 238 kHandshakeShouldSendAck, 239 kHandshakeWaitingForAck, 240 kHandshakeReady 241 }; 242 243 bool Init(const InternalDataChannelInit& config); 244 void DoClose(); 245 void UpdateState(); 246 void SetState(DataState state); 247 void DisconnectFromProvider(); 248 249 void DeliverQueuedReceivedData(); 250 251 void SendQueuedDataMessages(); 252 bool SendDataMessage(const DataBuffer& buffer, bool queue_if_blocked); 253 bool QueueSendDataMessage(const DataBuffer& buffer); 254 255 void SendQueuedControlMessages(); 256 void QueueControlMessage(const rtc::Buffer& buffer); 257 bool SendControlMessage(const rtc::Buffer& buffer); 258 259 std::string label_; 260 InternalDataChannelInit config_; 261 DataChannelObserver* observer_; 262 DataState state_; 263 cricket::DataChannelType data_channel_type_; 264 DataChannelProviderInterface* provider_; 265 HandshakeState handshake_state_; 266 bool connected_to_provider_; 267 bool send_ssrc_set_; 268 bool receive_ssrc_set_; 269 bool writable_; 270 uint32_t send_ssrc_; 271 uint32_t receive_ssrc_; 272 // Control messages that always have to get sent out before any queued 273 // data. 274 PacketQueue queued_control_data_; 275 PacketQueue queued_received_data_; 276 PacketQueue queued_send_data_; 277 }; 278 279 // Define proxy for DataChannelInterface. 280 BEGIN_PROXY_MAP(DataChannel) 281 PROXY_METHOD1(void, RegisterObserver, DataChannelObserver*) 282 PROXY_METHOD0(void, UnregisterObserver) 283 PROXY_CONSTMETHOD0(std::string, label) 284 PROXY_CONSTMETHOD0(bool, reliable) 285 PROXY_CONSTMETHOD0(bool, ordered) 286 PROXY_CONSTMETHOD0(uint16_t, maxRetransmitTime) 287 PROXY_CONSTMETHOD0(uint16_t, maxRetransmits) 288 PROXY_CONSTMETHOD0(std::string, protocol) 289 PROXY_CONSTMETHOD0(bool, negotiated) 290 PROXY_CONSTMETHOD0(int, id) 291 PROXY_CONSTMETHOD0(DataState, state) 292 PROXY_CONSTMETHOD0(uint64_t, buffered_amount) 293 PROXY_METHOD0(void, Close) 294 PROXY_METHOD1(bool, Send, const DataBuffer&) 295 END_PROXY() 296 297 } // namespace webrtc 298 299 #endif // TALK_APP_WEBRTC_DATACHANNEL_H_ 300