| OLD | NEW |
| (Empty) |
| 1 /* | |
| 2 * libjingle | |
| 3 * Copyright 2012 Google Inc. and Robin Seggelmann | |
| 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_MEDIA_SCTP_SCTPDATAENGINE_H_ | |
| 29 #define TALK_MEDIA_SCTP_SCTPDATAENGINE_H_ | |
| 30 | |
| 31 #include <errno.h> | |
| 32 #include <string> | |
| 33 #include <vector> | |
| 34 | |
| 35 namespace cricket { | |
| 36 // Some ERRNO values get re-#defined to WSA* equivalents in some talk/ | |
| 37 // headers. We save the original ones in an enum. | |
| 38 enum PreservedErrno { | |
| 39 SCTP_EINPROGRESS = EINPROGRESS, | |
| 40 SCTP_EWOULDBLOCK = EWOULDBLOCK | |
| 41 }; | |
| 42 } // namespace cricket | |
| 43 | |
| 44 #include "talk/media/base/codec.h" | |
| 45 #include "talk/media/base/mediachannel.h" | |
| 46 #include "talk/media/base/mediaengine.h" | |
| 47 #include "webrtc/base/buffer.h" | |
| 48 #include "webrtc/base/scoped_ptr.h" | |
| 49 | |
| 50 // Defined by "usrsctplib/usrsctp.h" | |
| 51 struct sockaddr_conn; | |
| 52 struct sctp_assoc_change; | |
| 53 struct sctp_stream_reset_event; | |
| 54 // Defined by <sys/socket.h> | |
| 55 struct socket; | |
| 56 namespace cricket { | |
| 57 // The highest stream ID (Sid) that SCTP allows, and the number of streams we | |
| 58 // tell SCTP we're going to use. | |
| 59 const uint32_t kMaxSctpSid = 1023; | |
| 60 | |
| 61 // This is the default SCTP port to use. It is passed along the wire and the | |
| 62 // connectee and connector must be using the same port. It is not related to the | |
| 63 // ports at the IP level. (Corresponds to: sockaddr_conn.sconn_port in | |
| 64 // usrsctp.h) | |
| 65 const int kSctpDefaultPort = 5000; | |
| 66 | |
| 67 class SctpDataMediaChannel; | |
| 68 | |
| 69 // A DataEngine that interacts with usrsctp. | |
| 70 // | |
| 71 // From channel calls, data flows like this: | |
| 72 // [worker thread (although it can in princple be another thread)] | |
| 73 // 1. SctpDataMediaChannel::SendData(data) | |
| 74 // 2. usrsctp_sendv(data) | |
| 75 // [worker thread returns; sctp thread then calls the following] | |
| 76 // 3. OnSctpOutboundPacket(wrapped_data) | |
| 77 // [sctp thread returns having posted a message for the worker thread] | |
| 78 // 4. SctpDataMediaChannel::OnMessage(wrapped_data) | |
| 79 // 5. SctpDataMediaChannel::OnPacketFromSctpToNetwork(wrapped_data) | |
| 80 // 6. NetworkInterface::SendPacket(wrapped_data) | |
| 81 // 7. ... across network ... a packet is sent back ... | |
| 82 // 8. SctpDataMediaChannel::OnPacketReceived(wrapped_data) | |
| 83 // 9. usrsctp_conninput(wrapped_data) | |
| 84 // [worker thread returns; sctp thread then calls the following] | |
| 85 // 10. OnSctpInboundData(data) | |
| 86 // [sctp thread returns having posted a message fot the worker thread] | |
| 87 // 11. SctpDataMediaChannel::OnMessage(inboundpacket) | |
| 88 // 12. SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(inboundpacket) | |
| 89 // 13. SctpDataMediaChannel::OnDataFromSctpToChannel(data) | |
| 90 // 14. SctpDataMediaChannel::SignalDataReceived(data) | |
| 91 // [from the same thread, methods registered/connected to | |
| 92 // SctpDataMediaChannel are called with the recieved data] | |
| 93 class SctpDataEngine : public DataEngineInterface, public sigslot::has_slots<> { | |
| 94 public: | |
| 95 SctpDataEngine(); | |
| 96 virtual ~SctpDataEngine(); | |
| 97 | |
| 98 virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type); | |
| 99 | |
| 100 virtual const std::vector<DataCodec>& data_codecs() { return codecs_; } | |
| 101 | |
| 102 static int SendThresholdCallback(struct socket* sock, uint32_t sb_free); | |
| 103 | |
| 104 private: | |
| 105 static int usrsctp_engines_count; | |
| 106 std::vector<DataCodec> codecs_; | |
| 107 | |
| 108 static SctpDataMediaChannel* GetChannelFromSocket(struct socket* sock); | |
| 109 }; | |
| 110 | |
| 111 // TODO(ldixon): Make into a special type of TypedMessageData. | |
| 112 // Holds data to be passed on to a channel. | |
| 113 struct SctpInboundPacket; | |
| 114 | |
| 115 class SctpDataMediaChannel : public DataMediaChannel, | |
| 116 public rtc::MessageHandler { | |
| 117 public: | |
| 118 // DataMessageType is used for the SCTP "Payload Protocol Identifier", as | |
| 119 // defined in http://tools.ietf.org/html/rfc4960#section-14.4 | |
| 120 // | |
| 121 // For the list of IANA approved values see: | |
| 122 // http://www.iana.org/assignments/sctp-parameters/sctp-parameters.xml | |
| 123 // The value is not used by SCTP itself. It indicates the protocol running | |
| 124 // on top of SCTP. | |
| 125 enum PayloadProtocolIdentifier { | |
| 126 PPID_NONE = 0, // No protocol is specified. | |
| 127 // Matches the PPIDs in mozilla source and | |
| 128 // https://datatracker.ietf.org/doc/draft-ietf-rtcweb-data-protocol Sec. 9 | |
| 129 // They're not yet assigned by IANA. | |
| 130 PPID_CONTROL = 50, | |
| 131 PPID_BINARY_PARTIAL = 52, | |
| 132 PPID_BINARY_LAST = 53, | |
| 133 PPID_TEXT_PARTIAL = 54, | |
| 134 PPID_TEXT_LAST = 51 | |
| 135 }; | |
| 136 | |
| 137 typedef std::set<uint32_t> StreamSet; | |
| 138 | |
| 139 // Given a thread which will be used to post messages (received data) to this | |
| 140 // SctpDataMediaChannel instance. | |
| 141 explicit SctpDataMediaChannel(rtc::Thread* thread); | |
| 142 virtual ~SctpDataMediaChannel(); | |
| 143 | |
| 144 // When SetSend is set to true, connects. When set to false, disconnects. | |
| 145 // Calling: "SetSend(true); SetSend(false); SetSend(true);" will connect, | |
| 146 // disconnect, and reconnect. | |
| 147 virtual bool SetSend(bool send); | |
| 148 // Unless SetReceive(true) is called, received packets will be discarded. | |
| 149 virtual bool SetReceive(bool receive); | |
| 150 | |
| 151 virtual bool SetSendParameters(const DataSendParameters& params); | |
| 152 virtual bool SetRecvParameters(const DataRecvParameters& params); | |
| 153 virtual bool AddSendStream(const StreamParams& sp); | |
| 154 virtual bool RemoveSendStream(uint32_t ssrc); | |
| 155 virtual bool AddRecvStream(const StreamParams& sp); | |
| 156 virtual bool RemoveRecvStream(uint32_t ssrc); | |
| 157 | |
| 158 // Called when Sctp gets data. The data may be a notification or data for | |
| 159 // OnSctpInboundData. Called from the worker thread. | |
| 160 virtual void OnMessage(rtc::Message* msg); | |
| 161 // Send data down this channel (will be wrapped as SCTP packets then given to | |
| 162 // sctp that will then post the network interface by OnMessage). | |
| 163 // Returns true iff successful data somewhere on the send-queue/network. | |
| 164 virtual bool SendData(const SendDataParams& params, | |
| 165 const rtc::Buffer& payload, | |
| 166 SendDataResult* result = NULL); | |
| 167 // A packet is received from the network interface. Posted to OnMessage. | |
| 168 virtual void OnPacketReceived(rtc::Buffer* packet, | |
| 169 const rtc::PacketTime& packet_time); | |
| 170 | |
| 171 // Exposed to allow Post call from c-callbacks. | |
| 172 rtc::Thread* worker_thread() const { return worker_thread_; } | |
| 173 | |
| 174 // Many of these things are unused by SCTP, but are needed to fulfill | |
| 175 // the MediaChannel interface. | |
| 176 virtual void OnRtcpReceived(rtc::Buffer* packet, | |
| 177 const rtc::PacketTime& packet_time) {} | |
| 178 virtual void OnReadyToSend(bool ready) {} | |
| 179 | |
| 180 void OnSendThresholdCallback(); | |
| 181 // Helper for debugging. | |
| 182 void set_debug_name(const std::string& debug_name) { | |
| 183 debug_name_ = debug_name; | |
| 184 } | |
| 185 const std::string& debug_name() const { return debug_name_; } | |
| 186 const struct socket* socket() const { return sock_; } | |
| 187 private: | |
| 188 sockaddr_conn GetSctpSockAddr(int port); | |
| 189 | |
| 190 bool SetSendCodecs(const std::vector<DataCodec>& codecs); | |
| 191 bool SetRecvCodecs(const std::vector<DataCodec>& codecs); | |
| 192 | |
| 193 // Creates the socket and connects. Sets sending_ to true. | |
| 194 bool Connect(); | |
| 195 // Closes the socket. Sets sending_ to false. | |
| 196 void Disconnect(); | |
| 197 | |
| 198 // Returns false when openning the socket failed; when successfull sets | |
| 199 // sending_ to true | |
| 200 bool OpenSctpSocket(); | |
| 201 // Sets sending_ to false and sock_ to NULL. | |
| 202 void CloseSctpSocket(); | |
| 203 | |
| 204 // Sends a SCTP_RESET_STREAM for all streams in closing_ssids_. | |
| 205 bool SendQueuedStreamResets(); | |
| 206 | |
| 207 // Adds a stream. | |
| 208 bool AddStream(const StreamParams &sp); | |
| 209 // Queues a stream for reset. | |
| 210 bool ResetStream(uint32_t ssrc); | |
| 211 | |
| 212 // Called by OnMessage to send packet on the network. | |
| 213 void OnPacketFromSctpToNetwork(rtc::Buffer* buffer); | |
| 214 // Called by OnMessage to decide what to do with the packet. | |
| 215 void OnInboundPacketFromSctpToChannel(SctpInboundPacket* packet); | |
| 216 void OnDataFromSctpToChannel(const ReceiveDataParams& params, | |
| 217 rtc::Buffer* buffer); | |
| 218 void OnNotificationFromSctp(rtc::Buffer* buffer); | |
| 219 void OnNotificationAssocChange(const sctp_assoc_change& change); | |
| 220 | |
| 221 void OnStreamResetEvent(const struct sctp_stream_reset_event* evt); | |
| 222 | |
| 223 // Responsible for marshalling incoming data to the channels listeners, and | |
| 224 // outgoing data to the network interface. | |
| 225 rtc::Thread* worker_thread_; | |
| 226 // The local and remote SCTP port to use. These are passed along the wire | |
| 227 // and the listener and connector must be using the same port. It is not | |
| 228 // related to the ports at the IP level. If set to -1, we default to | |
| 229 // kSctpDefaultPort. | |
| 230 int local_port_; | |
| 231 int remote_port_; | |
| 232 struct socket* sock_; // The socket created by usrsctp_socket(...). | |
| 233 | |
| 234 // sending_ is true iff there is a connected socket. | |
| 235 bool sending_; | |
| 236 // receiving_ controls whether inbound packets are thrown away. | |
| 237 bool receiving_; | |
| 238 | |
| 239 // When a data channel opens a stream, it goes into open_streams_. When we | |
| 240 // want to close it, the stream's ID goes into queued_reset_streams_. When | |
| 241 // we actually transmit a RE-CONFIG chunk with that stream ID, the ID goes | |
| 242 // into sent_reset_streams_. When we get a response RE-CONFIG chunk back | |
| 243 // acknowledging the reset, we remove the stream ID from | |
| 244 // sent_reset_streams_. We use sent_reset_streams_ to differentiate | |
| 245 // between acknowledgment RE-CONFIG and peer-initiated RE-CONFIGs. | |
| 246 StreamSet open_streams_; | |
| 247 StreamSet queued_reset_streams_; | |
| 248 StreamSet sent_reset_streams_; | |
| 249 | |
| 250 // A human-readable name for debugging messages. | |
| 251 std::string debug_name_; | |
| 252 }; | |
| 253 | |
| 254 } // namespace cricket | |
| 255 | |
| 256 #endif // TALK_MEDIA_SCTP_SCTPDATAENGINE_H_ | |
| OLD | NEW |