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 WEBRTC_BASE_ASYNCPACKETSOCKET_H_
12#define WEBRTC_BASE_ASYNCPACKETSOCKET_H_
13
14#include "webrtc/base/dscp.h"
15#include "webrtc/base/sigslot.h"
16#include "webrtc/base/socket.h"
17#include "webrtc/base/timeutils.h"
18
19namespace rtc {
20
21// This structure holds the info needed to update the packet send time header
22// extension, including the information needed to update the authentication tag
23// after changing the value.
24struct PacketTimeUpdateParams {
25  PacketTimeUpdateParams()
26      : rtp_sendtime_extension_id(-1), srtp_auth_tag_len(-1),
27        srtp_packet_index(-1) {
28  }
29
30  int rtp_sendtime_extension_id;    // extension header id present in packet.
31  std::vector<char> srtp_auth_key;  // Authentication key.
32  int srtp_auth_tag_len;            // Authentication tag length.
33  int64 srtp_packet_index;          // Required for Rtp Packet authentication.
34};
35
36// This structure holds meta information for the packet which is about to send
37// over network.
38struct PacketOptions {
39  PacketOptions() : dscp(DSCP_NO_CHANGE) {}
40  explicit PacketOptions(DiffServCodePoint dscp) : dscp(dscp) {}
41
42  DiffServCodePoint dscp;
43  PacketTimeUpdateParams packet_time_params;
44};
45
46// This structure will have the information about when packet is actually
47// received by socket.
48struct PacketTime {
49  PacketTime() : timestamp(-1), not_before(-1) {}
50  PacketTime(int64 timestamp, int64 not_before)
51      : timestamp(timestamp), not_before(not_before) {
52  }
53
54  int64 timestamp;  // Receive time after socket delivers the data.
55  int64 not_before; // Earliest possible time the data could have arrived,
56                    // indicating the potential error in the |timestamp| value,
57                    // in case the system, is busy. For example, the time of
58                    // the last select() call.
59                    // If unknown, this value will be set to zero.
60};
61
62inline PacketTime CreatePacketTime(int64 not_before) {
63  return PacketTime(TimeMicros(), not_before);
64}
65
66// Provides the ability to receive packets asynchronously. Sends are not
67// buffered since it is acceptable to drop packets under high load.
68class AsyncPacketSocket : public sigslot::has_slots<> {
69 public:
70  enum State {
71    STATE_CLOSED,
72    STATE_BINDING,
73    STATE_BOUND,
74    STATE_CONNECTING,
75    STATE_CONNECTED
76  };
77
78  AsyncPacketSocket() { }
79  virtual ~AsyncPacketSocket() { }
80
81  // Returns current local address. Address may be set to NULL if the
82  // socket is not bound yet (GetState() returns STATE_BINDING).
83  virtual SocketAddress GetLocalAddress() const = 0;
84
85  // Returns remote address. Returns zeroes if this is not a client TCP socket.
86  virtual SocketAddress GetRemoteAddress() const = 0;
87
88  // Send a packet.
89  virtual int Send(const void *pv, size_t cb, const PacketOptions& options) = 0;
90  virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr,
91                     const PacketOptions& options) = 0;
92
93  // Close the socket.
94  virtual int Close() = 0;
95
96  // Returns current state of the socket.
97  virtual State GetState() const = 0;
98
99  // Get/set options.
100  virtual int GetOption(Socket::Option opt, int* value) = 0;
101  virtual int SetOption(Socket::Option opt, int value) = 0;
102
103  // Get/Set current error.
104  // TODO: Remove SetError().
105  virtual int GetError() const = 0;
106  virtual void SetError(int error) = 0;
107
108  // Emitted each time a packet is read. Used only for UDP and
109  // connected TCP sockets.
110  sigslot::signal5<AsyncPacketSocket*, const char*, size_t,
111                   const SocketAddress&,
112                   const PacketTime&> SignalReadPacket;
113
114  // Emitted when the socket is currently able to send.
115  sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
116
117  // Emitted after address for the socket is allocated, i.e. binding
118  // is finished. State of the socket is changed from BINDING to BOUND
119  // (for UDP and server TCP sockets) or CONNECTING (for client TCP
120  // sockets).
121  sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
122
123  // Emitted for client TCP sockets when state is changed from
124  // CONNECTING to CONNECTED.
125  sigslot::signal1<AsyncPacketSocket*> SignalConnect;
126
127  // Emitted for client TCP sockets when state is changed from
128  // CONNECTED to CLOSED.
129  sigslot::signal2<AsyncPacketSocket*, int> SignalClose;
130
131  // Used only for listening TCP sockets.
132  sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection;
133
134 private:
135  DISALLOW_EVIL_CONSTRUCTORS(AsyncPacketSocket);
136};
137
138}  // namespace rtc
139
140#endif  // WEBRTC_BASE_ASYNCPACKETSOCKET_H_
141