src/third_party/webrtc/test/channel_transport/udp_transport_impl.h

   1 /*
   2  *  Copyright (c) 2012 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_TEST_CHANNEL_TRANSPORT_UDP_TRANSPORT_IMPL_H_
  12 #define WEBRTC_TEST_CHANNEL_TRANSPORT_UDP_TRANSPORT_IMPL_H_
  13
  14 #include "webrtc/test/channel_transport/udp_socket_wrapper.h"
  15 #include "webrtc/test/channel_transport/udp_transport.h"
  16
  17 namespace webrtc {
  18
  19 class CriticalSectionWrapper;
  20 class RWLockWrapper;
  21
  22 namespace test {
  23
  24 class UdpSocketManager;
  25
  26 class UdpTransportImpl : public UdpTransport
  27 {
  28 public:
  29     // A factory that returns a wrapped UDP socket or equivalent.
  30     class SocketFactoryInterface {
  31     public:
  32         virtual ~SocketFactoryInterface() {}
  33         virtual UdpSocketWrapper* CreateSocket(const int32_t id,
  34                                                UdpSocketManager* mgr,
  35                                                CallbackObj obj,
  36                                                IncomingSocketCallback cb,
  37                                                bool ipV6Enable,
  38                                                bool disableGQOS) = 0;
  39     };
  40
  41     // Constructor, only called by UdpTransport::Create and tests.
  42     // The constructor takes ownership of the "maker".
  43     // The constructor does not take ownership of socket_manager.
  44     UdpTransportImpl(const int32_t id,
  45                      SocketFactoryInterface* maker,
  46                      UdpSocketManager* socket_manager);
  47     virtual ~UdpTransportImpl();
  48
  49     // UdpTransport functions
  50     virtual int32_t InitializeSendSockets(
  51         const char* ipAddr,
  52         const uint16_t rtpPort,
  53         const uint16_t rtcpPort = 0) OVERRIDE;
  54     virtual int32_t InitializeReceiveSockets(
  55         UdpTransportData* const packetCallback,
  56         const uint16_t rtpPort,
  57         const char* ipAddr = NULL,
  58         const char* multicastIpAddr = NULL,
  59         const uint16_t rtcpPort = 0) OVERRIDE;
  60     virtual int32_t InitializeSourcePorts(
  61         const uint16_t rtpPort,
  62         const uint16_t rtcpPort = 0) OVERRIDE;
  63     virtual int32_t SourcePorts(uint16_t& rtpPort,
  64                                 uint16_t& rtcpPort) const OVERRIDE;
  65     virtual int32_t ReceiveSocketInformation(
  66         char ipAddr[kIpAddressVersion6Length],
  67         uint16_t& rtpPort,
  68         uint16_t& rtcpPort,
  69         char multicastIpAddr[kIpAddressVersion6Length]) const OVERRIDE;
  70     virtual int32_t SendSocketInformation(
  71         char ipAddr[kIpAddressVersion6Length],
  72         uint16_t& rtpPort,
  73         uint16_t& rtcpPort) const OVERRIDE;
  74     virtual int32_t RemoteSocketInformation(
  75         char ipAddr[kIpAddressVersion6Length],
  76         uint16_t& rtpPort,
  77         uint16_t& rtcpPort) const OVERRIDE;
  78     virtual int32_t SetQoS(const bool QoS,
  79                            const int32_t serviceType,
  80                            const uint32_t maxBitrate = 0,
  81                            const int32_t overrideDSCP = 0,
  82                            const bool audio = false) OVERRIDE;
  83     virtual int32_t QoS(bool& QoS, int32_t& serviceType,
  84                         int32_t& overrideDSCP) const OVERRIDE;
  85     virtual int32_t SetToS(const int32_t DSCP,
  86                            const bool useSetSockOpt = false) OVERRIDE;
  87     virtual int32_t ToS(int32_t& DSCP, bool& useSetSockOpt) const OVERRIDE;
  88     virtual int32_t SetPCP(const int32_t PCP) OVERRIDE;
  89     virtual int32_t PCP(int32_t& PCP) const OVERRIDE;
  90     virtual int32_t EnableIpV6() OVERRIDE;
  91     virtual bool IpV6Enabled() const OVERRIDE;
  92     virtual int32_t SetFilterIP(
  93         const char filterIPAddress[kIpAddressVersion6Length]) OVERRIDE;
  94     virtual int32_t FilterIP(
  95         char filterIPAddress[kIpAddressVersion6Length]) const OVERRIDE;
  96     virtual int32_t SetFilterPorts(const uint16_t rtpFilterPort,
  97                                    const uint16_t rtcpFilterPort) OVERRIDE;
  98     virtual int32_t FilterPorts(uint16_t& rtpFilterPort,
  99                                 uint16_t& rtcpFilterPort) const OVERRIDE;
 100     virtual int32_t StartReceiving(
 101         const uint32_t numberOfSocketBuffers) OVERRIDE;
 102     virtual int32_t StopReceiving() OVERRIDE;
 103     virtual bool Receiving() const OVERRIDE;
 104     virtual bool SendSocketsInitialized() const OVERRIDE;
 105     virtual bool SourcePortsInitialized() const OVERRIDE;
 106     virtual bool ReceiveSocketsInitialized() const OVERRIDE;
 107     virtual int32_t SendRaw(const int8_t* data,
 108                             uint32_t length, int32_t isRTCP,
 109                             uint16_t portnr = 0,
 110                             const char* ip = NULL) OVERRIDE;
 111     virtual int32_t SendRTPPacketTo(const int8_t *data,
 112                                     uint32_t length,
 113                                     const SocketAddress& to) OVERRIDE;
 114     virtual int32_t SendRTCPPacketTo(const int8_t *data,
 115                                      uint32_t length,
 116                                      const SocketAddress& to) OVERRIDE;
 117     virtual int32_t SendRTPPacketTo(const int8_t *data,
 118                                     uint32_t length,
 119                                     uint16_t rtpPort) OVERRIDE;
 120     virtual int32_t SendRTCPPacketTo(const int8_t *data,
 121                                      uint32_t length,
 122                                      uint16_t rtcpPort) OVERRIDE;
 123     // Transport functions
 124     virtual int SendPacket(int channel, const void* data, int length) OVERRIDE;
 125     virtual int SendRTCPPacket(int channel,
 126                                const void* data,
 127                                int length) OVERRIDE;
 128
 129     // UdpTransport functions continue.
 130     virtual int32_t SetSendIP(const char* ipaddr) OVERRIDE;
 131     virtual int32_t SetSendPorts(const uint16_t rtpPort,
 132                                  const uint16_t rtcpPort = 0) OVERRIDE;
 133
 134     virtual ErrorCode LastError() const OVERRIDE;
 135
 136     virtual int32_t IPAddressCached(const SocketAddress& address,
 137                                     char* ip,
 138                                     uint32_t& ipSize,
 139                                     uint16_t& sourcePort) OVERRIDE;
 140
 141     int32_t Id() const {return _id;}
 142 protected:
 143     // IncomingSocketCallback signature functions for receiving callbacks from
 144     // UdpSocketWrapper.
 145     static void IncomingRTPCallback(CallbackObj obj,
 146                                     const int8_t* rtpPacket,
 147                                     int32_t rtpPacketLength,
 148                                     const SocketAddress* from);
 149     static void IncomingRTCPCallback(CallbackObj obj,
 150                                      const int8_t* rtcpPacket,
 151                                      int32_t rtcpPacketLength,
 152                                      const SocketAddress* from);
 153
 154     void CloseSendSockets();
 155     void CloseReceiveSockets();
 156
 157     // Update _remoteRTPAddr according to _destPort and _destIP
 158     void BuildRemoteRTPAddr();
 159     // Update _remoteRTCPAddr according to _destPortRTCP and _destIP
 160     void BuildRemoteRTCPAddr();
 161
 162     void BuildSockaddrIn(uint16_t portnr, const char* ip,
 163                          SocketAddress& remoteAddr) const;
 164
 165     ErrorCode BindLocalRTPSocket();
 166     ErrorCode BindLocalRTCPSocket();
 167
 168     ErrorCode BindRTPSendSocket();
 169     ErrorCode BindRTCPSendSocket();
 170
 171     void IncomingRTPFunction(const int8_t* rtpPacket,
 172                              int32_t rtpPacketLength,
 173                              const SocketAddress* from);
 174     void IncomingRTCPFunction(const int8_t* rtcpPacket,
 175                               int32_t rtcpPacketLength,
 176                               const SocketAddress* from);
 177
 178     bool FilterIPAddress(const SocketAddress* fromAddress);
 179
 180     bool SetSockOptUsed();
 181
 182     int32_t EnableQoS(int32_t serviceType, bool audio,
 183                       uint32_t maxBitrate, int32_t overrideDSCP);
 184
 185     int32_t DisableQoS();
 186
 187 private:
 188     void GetCachedAddress(char* ip, uint32_t& ipSize,
 189                           uint16_t& sourcePort);
 190
 191     int32_t _id;
 192     SocketFactoryInterface* _socket_creator;
 193     // Protects the sockets from being re-configured while receiving packets.
 194     CriticalSectionWrapper* _crit;
 195     CriticalSectionWrapper* _critFilter;
 196     // _packetCallback's critical section.
 197     CriticalSectionWrapper* _critPacketCallback;
 198     UdpSocketManager* _mgr;
 199     ErrorCode _lastError;
 200
 201     // Remote RTP and RTCP ports.
 202     uint16_t _destPort;
 203     uint16_t _destPortRTCP;
 204
 205     // Local RTP and RTCP ports.
 206     uint16_t _localPort;
 207     uint16_t _localPortRTCP;
 208
 209     // Local port number when the local port for receiving and local port number
 210     // for sending are not the same.
 211     uint16_t _srcPort;
 212     uint16_t _srcPortRTCP;
 213
 214     // Remote port from which last received packet was sent.
 215     uint16_t _fromPort;
 216     uint16_t _fromPortRTCP;
 217
 218     char _fromIP[kIpAddressVersion6Length];
 219     char _destIP[kIpAddressVersion6Length];
 220     char _localIP[kIpAddressVersion6Length];
 221     char _localMulticastIP[kIpAddressVersion6Length];
 222
 223     UdpSocketWrapper* _ptrRtpSocket;
 224     UdpSocketWrapper* _ptrRtcpSocket;
 225
 226     // Local port when the local port for receiving and local port for sending
 227     // are not the same.
 228     UdpSocketWrapper* _ptrSendRtpSocket;
 229     UdpSocketWrapper* _ptrSendRtcpSocket;
 230
 231     SocketAddress _remoteRTPAddr;
 232     SocketAddress _remoteRTCPAddr;
 233
 234     SocketAddress _localRTPAddr;
 235     SocketAddress _localRTCPAddr;
 236
 237     int32_t _tos;
 238     bool _receiving;
 239     bool _useSetSockOpt;
 240     bool _qos;
 241     int32_t _pcp;
 242     bool _ipV6Enabled;
 243     int32_t _serviceType;
 244     int32_t _overrideDSCP;
 245     uint32_t _maxBitrate;
 246
 247     // Cache used by GetCachedAddress(..).
 248     RWLockWrapper* _cachLock;
 249     SocketAddress _previousAddress;
 250     char _previousIP[kIpAddressVersion6Length];
 251     uint32_t _previousIPSize;
 252     uint16_t _previousSourcePort;
 253
 254     SocketAddress _filterIPAddress;
 255     uint16_t _rtpFilterPort;
 256     uint16_t _rtcpFilterPort;
 257
 258     UdpTransportData* _packetCallback;
 259 };
 260
 261 }  // namespace test
 262 }  // namespace webrtc
 263
 264 #endif  // WEBRTC_TEST_CHANNEL_TRANSPORT_UDP_TRANSPORT_IMPL_H_