1 /*
2  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #ifndef RTC_BASE_ASYNC_PACKET_SOCKET_H_
12 #define RTC_BASE_ASYNC_PACKET_SOCKET_H_
13 
14 #include <vector>
15 
16 #include "rtc_base/constructor_magic.h"
17 #include "rtc_base/dscp.h"
18 #include "rtc_base/network/sent_packet.h"
19 #include "rtc_base/socket.h"
20 #include "rtc_base/system/rtc_export.h"
21 #include "rtc_base/third_party/sigslot/sigslot.h"
22 #include "rtc_base/time_utils.h"
23 
24 namespace rtc {
25 
26 // This structure holds the info needed to update the packet send time header
27 // extension, including the information needed to update the authentication tag
28 // after changing the value.
29 struct PacketTimeUpdateParams {
30   PacketTimeUpdateParams();
31   PacketTimeUpdateParams(const PacketTimeUpdateParams& other);
32   ~PacketTimeUpdateParams();
33 
34   int rtp_sendtime_extension_id = -1;  // extension header id present in packet.
35   std::vector<char> srtp_auth_key;     // Authentication key.
36   int srtp_auth_tag_len = -1;          // Authentication tag length.
37   int64_t srtp_packet_index = -1;  // Required for Rtp Packet authentication.
38 };
39 
40 // This structure holds meta information for the packet which is about to send
41 // over network.
42 struct RTC_EXPORT PacketOptions {
43   PacketOptions();
44   explicit PacketOptions(DiffServCodePoint dscp);
45   PacketOptions(const PacketOptions& other);
46   ~PacketOptions();
47 
48   DiffServCodePoint dscp = DSCP_NO_CHANGE;
49   // When used with RTP packets (for example, webrtc::PacketOptions), the value
50   // should be 16 bits. A value of -1 represents "not set".
51   int64_t packet_id = -1;
52   PacketTimeUpdateParams packet_time_params;
53   // PacketInfo is passed to SentPacket when signaling this packet is sent.
54   PacketInfo info_signaled_after_sent;
55 };
56 
57 // Provides the ability to receive packets asynchronously. Sends are not
58 // buffered since it is acceptable to drop packets under high load.
59 class RTC_EXPORT AsyncPacketSocket : public sigslot::has_slots<> {
60  public:
61   enum State {
62     STATE_CLOSED,
63     STATE_BINDING,
64     STATE_BOUND,
65     STATE_CONNECTING,
66     STATE_CONNECTED
67   };
68 
69   AsyncPacketSocket();
70   ~AsyncPacketSocket() override;
71 
72   // Returns current local address. Address may be set to null if the
73   // socket is not bound yet (GetState() returns STATE_BINDING).
74   virtual SocketAddress GetLocalAddress() const = 0;
75 
76   // Returns remote address. Returns zeroes if this is not a client TCP socket.
77   virtual SocketAddress GetRemoteAddress() const = 0;
78 
79   // Send a packet.
80   virtual int Send(const void* pv, size_t cb, const PacketOptions& options) = 0;
81   virtual int SendTo(const void* pv,
82                      size_t cb,
83                      const SocketAddress& addr,
84                      const PacketOptions& options) = 0;
85 
86   // Close the socket.
87   virtual int Close() = 0;
88 
89   // Returns current state of the socket.
90   virtual State GetState() const = 0;
91 
92   // Get/set options.
93   virtual int GetOption(Socket::Option opt, int* value) = 0;
94   virtual int SetOption(Socket::Option opt, int value) = 0;
95 
96   // Get/Set current error.
97   // TODO: Remove SetError().
98   virtual int GetError() const = 0;
99   virtual void SetError(int error) = 0;
100 
101   // Emitted each time a packet is read. Used only for UDP and
102   // connected TCP sockets.
103   sigslot::signal5<AsyncPacketSocket*,
104                    const char*,
105                    size_t,
106                    const SocketAddress&,
107                    // TODO(bugs.webrtc.org/9584): Change to passing the int64_t
108                    // timestamp by value.
109                    const int64_t&>
110       SignalReadPacket;
111 
112   // Emitted each time a packet is sent.
113   sigslot::signal2<AsyncPacketSocket*, const SentPacket&> SignalSentPacket;
114 
115   // Emitted when the socket is currently able to send.
116   sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
117 
118   // Emitted after address for the socket is allocated, i.e. binding
119   // is finished. State of the socket is changed from BINDING to BOUND
120   // (for UDP and server TCP sockets) or CONNECTING (for client TCP
121   // sockets).
122   sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
123 
124   // Emitted for client TCP sockets when state is changed from
125   // CONNECTING to CONNECTED.
126   sigslot::signal1<AsyncPacketSocket*> SignalConnect;
127 
128   // Emitted for client TCP sockets when state is changed from
129   // CONNECTED to CLOSED.
130   sigslot::signal2<AsyncPacketSocket*, int> SignalClose;
131 
132   // Used only for listening TCP sockets.
133   sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection;
134 
135  private:
136   RTC_DISALLOW_COPY_AND_ASSIGN(AsyncPacketSocket);
137 };
138 
139 void CopySocketInformationToPacketInfo(size_t packet_size_bytes,
140                                        const AsyncPacketSocket& socket_from,
141                                        bool is_connectionless,
142                                        rtc::PacketInfo* info);
143 
144 }  // namespace rtc
145 
146 #endif  // RTC_BASE_ASYNC_PACKET_SOCKET_H_
147