text: /*
   *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  #ifndef RTC_BASE_ASYNCPACKETSOCKET_H_
  #define RTC_BASE_ASYNCPACKETSOCKET_H_
  
  #include "rtc_base/constructormagic.h"
  #include "rtc_base/deprecation.h"
  #include "rtc_base/dscp.h"
  #include "rtc_base/socket.h"
  #include "rtc_base/third_party/sigslot/sigslot.h"
  #include "rtc_base/timeutils.h"
  
  namespace rtc {
  
  // This structure holds the info needed to update the packet send time header
  // extension, including the information needed to update the authentication tag
  // after changing the value.
  struct PacketTimeUpdateParams {
    PacketTimeUpdateParams();
    PacketTimeUpdateParams(const PacketTimeUpdateParams& other);
    ~PacketTimeUpdateParams();
  
    int rtp_sendtime_extension_id = -1;  // extension header id present in packet.
    std::vector<char> srtp_auth_key;     // Authentication key.
    int srtp_auth_tag_len = -1;          // Authentication tag length.
    int64_t srtp_packet_index = -1;  // Required for Rtp Packet authentication.
  };
  
  // This structure holds meta information for the packet which is about to send
  // over network.
  struct PacketOptions {
    PacketOptions();
    explicit PacketOptions(DiffServCodePoint dscp);
    PacketOptions(const PacketOptions& other);
    ~PacketOptions();
  
    DiffServCodePoint dscp = DSCP_NO_CHANGE;
    // When used with RTP packets (for example, webrtc::PacketOptions), the value
    // should be 16 bits. A value of -1 represents "not set".
    int64_t packet_id = -1;
    PacketTimeUpdateParams packet_time_params;
    // PacketInfo is passed to SentPacket when signaling this packet is sent.
    PacketInfo info_signaled_after_sent;
  };
  
  // TODO(bugs.webrtc.org/9584): Compatibility alias, delete as soon as downstream
  // code is updated.
  typedef int64_t PacketTime;
  
  // Provides the ability to receive packets asynchronously. Sends are not
  // buffered since it is acceptable to drop packets under high load.
  class AsyncPacketSocket : public sigslot::has_slots<> {
   public:
    enum State {
      STATE_CLOSED,
      STATE_BINDING,
      STATE_BOUND,
      STATE_CONNECTING,
      STATE_CONNECTED
    };
  
    AsyncPacketSocket();
    ~AsyncPacketSocket() override;
  
    // Returns current local address. Address may be set to null if the
    // socket is not bound yet (GetState() returns STATE_BINDING).
    virtual SocketAddress GetLocalAddress() const = 0;
  
    // Returns remote address. Returns zeroes if this is not a client TCP socket.
    virtual SocketAddress GetRemoteAddress() const = 0;
  
    // Send a packet.
    virtual int Send(const void* pv, size_t cb, const PacketOptions& options) = 0;
    virtual int SendTo(const void* pv,
                       size_t cb,
                       const SocketAddress& addr,
                       const PacketOptions& options) = 0;
  
    // Close the socket.
    virtual int Close() = 0;
  
    // Returns current state of the socket.
    virtual State GetState() const = 0;
  
    // Get/set options.
    virtual int GetOption(Socket::Option opt, int* value) = 0;
    virtual int SetOption(Socket::Option opt, int value) = 0;
  
    // Get/Set current error.
    // TODO: Remove SetError().
    virtual int GetError() const = 0;
    virtual void SetError(int error) = 0;
  
    // Emitted each time a packet is read. Used only for UDP and
    // connected TCP sockets.
    sigslot::signal5<AsyncPacketSocket*,
                     const char*,
                     size_t,
                     const SocketAddress&,
                     // TODO(bugs.webrtc.org/9584): Change to passing the int64_t
                     // timestamp by value.
                     const int64_t&>
        SignalReadPacket;
  
    // Emitted each time a packet is sent.
    sigslot::signal2<AsyncPacketSocket*, const SentPacket&> SignalSentPacket;
  
    // Emitted when the socket is currently able to send.
    sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
  
    // Emitted after address for the socket is allocated, i.e. binding
    // is finished. State of the socket is changed from BINDING to BOUND
    // (for UDP and server TCP sockets) or CONNECTING (for client TCP
    // sockets).
    sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
  
    // Emitted for client TCP sockets when state is changed from
    // CONNECTING to CONNECTED.
    sigslot::signal1<AsyncPacketSocket*> SignalConnect;
  
    // Emitted for client TCP sockets when state is changed from
    // CONNECTED to CLOSED.
    sigslot::signal2<AsyncPacketSocket*, int> SignalClose;
  
    // Used only for listening TCP sockets.
    sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection;
  
   private:
    RTC_DISALLOW_COPY_AND_ASSIGN(AsyncPacketSocket);
  };
  
  void CopySocketInformationToPacketInfo(size_t packet_size_bytes,
                                         const AsyncPacketSocket& socket_from,
                                         bool is_connectionless,
                                         rtc::PacketInfo* info);
  
  }  // namespace rtc
  
  #endif  // RTC_BASE_ASYNCPACKETSOCKET_H_
  