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 |