Revert of Moved webrtc/test/channel_transport/ into webrtc/voice_engine/test/

webrtc/test/channel_transport/udp_transport_impl.cc

+/*
+ *  Copyright (c) 2012 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.
+ */
+
+#include "webrtc/test/channel_transport/udp_transport_impl.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+#include <arpa/inet.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <unistd.h>
+#ifndef WEBRTC_IOS
+#include <net/if_arp.h>
+#endif
+#endif // defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+
+#if defined(WEBRTC_MAC)
+#include <ifaddrs.h>
+#include <machine/types.h>
+#endif
+#if defined(WEBRTC_LINUX)
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#endif
+
+#include "webrtc/common_types.h"
+#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
+#include "webrtc/system_wrappers/include/trace.h"
+#include "webrtc/test/channel_transport/udp_socket_manager_wrapper.h"
+#include "webrtc/typedefs.h"
+
+#if defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+#define GetLastError() errno
+
+#define IFRSIZE ((int)(size * sizeof (struct ifreq)))
+
+#define NLMSG_OK_NO_WARNING(nlh,len)                                    \
+  ((len) >= (int)sizeof(struct nlmsghdr) &&                             \
+   (int)(nlh)->nlmsg_len >= (int)sizeof(struct nlmsghdr) &&             \
+   (int)(nlh)->nlmsg_len <= (len))
+
+#endif // defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+
+namespace webrtc {
+namespace test {
+
+class SocketFactory : public UdpTransportImpl::SocketFactoryInterface {
+ public:
+  UdpSocketWrapper* CreateSocket(const int32_t id,
+                                 UdpSocketManager* mgr,
+                                 CallbackObj obj,
+                                 IncomingSocketCallback cb,
+                                 bool ipV6Enable,
+                                 bool disableGQOS) override {
+    return UdpSocketWrapper::CreateSocket(id, mgr, obj, cb, ipV6Enable,
+                                          disableGQOS);
+  }
+};
+
+// Creates an UdpTransport using the definition of SocketFactory above,
+// and passes (creating if needed) a pointer to the static singleton
+// UdpSocketManager.
+UdpTransport* UdpTransport::Create(const int32_t id,
+                                   uint8_t& numSocketThreads)
+{
+  return new UdpTransportImpl(id,
+                              new SocketFactory(),
+                              UdpSocketManager::Create(id, numSocketThreads));
+}
+
+// Deletes the UdpTransport and decrements the refcount of the
+// static singleton UdpSocketManager, possibly destroying it.
+// Should only be used on UdpTransports that are created using Create.
+void UdpTransport::Destroy(UdpTransport* module)
+{
+    if(module)
+    {
+        delete module;
+        UdpSocketManager::Return();
+    }
+}
+
+UdpTransportImpl::UdpTransportImpl(const int32_t id,
+                                   SocketFactoryInterface* maker,
+                                   UdpSocketManager* socket_manager)
+    : _id(id),
+      _socket_creator(maker),
+      _crit(CriticalSectionWrapper::CreateCriticalSection()),
+      _critFilter(CriticalSectionWrapper::CreateCriticalSection()),
+      _critPacketCallback(CriticalSectionWrapper::CreateCriticalSection()),
+      _mgr(socket_manager),
+      _lastError(kNoSocketError),
+      _destPort(0),
+      _destPortRTCP(0),
+      _localPort(0),
+      _localPortRTCP(0),
+      _srcPort(0),
+      _srcPortRTCP(0),
+      _fromPort(0),
+      _fromPortRTCP(0),
+      _fromIP(),
+      _destIP(),
+      _localIP(),
+      _localMulticastIP(),
+      _ptrRtpSocket(NULL),
+      _ptrRtcpSocket(NULL),
+      _ptrSendRtpSocket(NULL),
+      _ptrSendRtcpSocket(NULL),
+      _remoteRTPAddr(),
+      _remoteRTCPAddr(),
+      _localRTPAddr(),
+      _localRTCPAddr(),
+      _tos(0),
+      _receiving(false),
+      _useSetSockOpt(false),
+      _qos(false),
+      _pcp(0),
+      _ipV6Enabled(false),
+      _serviceType(0),
+      _overrideDSCP(0),
+      _maxBitrate(0),
+      _cachLock(RWLockWrapper::CreateRWLock()),
+      _previousAddress(),
+      _previousIP(),
+      _previousIPSize(0),
+      _previousSourcePort(0),
+      _filterIPAddress(),
+      _rtpFilterPort(0),
+      _rtcpFilterPort(0),
+      _packetCallback(0)
+{
+    memset(&_remoteRTPAddr, 0, sizeof(_remoteRTPAddr));
+    memset(&_remoteRTCPAddr, 0, sizeof(_remoteRTCPAddr));
+    memset(&_localRTPAddr, 0, sizeof(_localRTPAddr));
+    memset(&_localRTCPAddr, 0, sizeof(_localRTCPAddr));
+
+    memset(_fromIP, 0, sizeof(_fromIP));
+    memset(_destIP, 0, sizeof(_destIP));
+    memset(_localIP, 0, sizeof(_localIP));
+    memset(_localMulticastIP, 0, sizeof(_localMulticastIP));
+
+    memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
+
+    WEBRTC_TRACE(kTraceMemory, kTraceTransport, id, "%s created", __FUNCTION__);
+}
+
+UdpTransportImpl::~UdpTransportImpl()
+{
+    CloseSendSockets();
+    CloseReceiveSockets();
+    delete _crit;
+    delete _critFilter;
+    delete _critPacketCallback;
+    delete _cachLock;
+    delete _socket_creator;
+
+    WEBRTC_TRACE(kTraceMemory, kTraceTransport, _id, "%s deleted",
+                 __FUNCTION__);
+}
+
+UdpTransport::ErrorCode UdpTransportImpl::LastError() const
+{
+    return _lastError;
+}
+
+bool SameAddress(const SocketAddress& address1, const SocketAddress& address2)
+{
+    return (memcmp(&address1,&address2,sizeof(address1)) == 0);
+}
+
+void UdpTransportImpl::GetCachedAddress(char* ip,
+                                        uint32_t& ipSize,
+                                        uint16_t& sourcePort)
+{
+    const uint32_t originalIPSize = ipSize;
+    // If the incoming string is too small, fill it as much as there is room
+    // for. Make sure that there is room for the '\0' character.
+    ipSize = (ipSize - 1 < _previousIPSize) ? ipSize - 1 : _previousIPSize;
+    memcpy(ip,_previousIP,sizeof(int8_t)*(ipSize + 1));
+    ip[originalIPSize - 1] = '\0';
+    sourcePort = _previousSourcePort;
+}
+
+int32_t UdpTransportImpl::IPAddressCached(const SocketAddress& address,
+                                          char* ip,
+                                          uint32_t& ipSize,
+                                          uint16_t& sourcePort)
+{
+    {
+        ReadLockScoped rl(*_cachLock);
+        // Check if the old address can be re-used (is the same).
+        if(SameAddress(address,_previousAddress))
+        {
+            GetCachedAddress(ip,ipSize,sourcePort);
+            return 0;
+        }
+    }
+    // Get the new address and store it.
+    WriteLockScoped wl(*_cachLock);
+    ipSize = kIpAddressVersion6Length;
+    if(IPAddress(address,_previousIP,ipSize,_previousSourcePort) != 0)
+    {
+        return -1;
+    }
+    _previousIPSize = ipSize;
+    memcpy(&_previousAddress, &address, sizeof(address));
+    // Address has been cached at this point.
+    GetCachedAddress(ip,ipSize,sourcePort);
+    return 0;
+}
+
+int32_t UdpTransportImpl::InitializeReceiveSockets(
+    UdpTransportData* const packetCallback,
+    const uint16_t portnr,
+    const char* ip,
+    const char* multicastIpAddr,
+    const uint16_t rtcpPort)
+{
+    {
+        CriticalSectionScoped cs(_critPacketCallback);
+        _packetCallback = packetCallback;
+
+        if(packetCallback == NULL)
+        {
+            WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                         "Closing down receive sockets");
+            return 0;
+        }
+    }
+
+    CriticalSectionScoped cs(_crit);
+    CloseReceiveSockets();
+
+    if(portnr == 0)
+    {
+        // TODO (hellner): why not just fail here?
+        if(_destPort == 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "InitializeReceiveSockets port 0 not allowed");
+            _lastError = kPortInvalid;
+            return -1;
+        }
+        _localPort = _destPort;
+    } else {
+        _localPort = portnr;
+    }
+    if(rtcpPort)
+    {
+        _localPortRTCP = rtcpPort;
+    }else {
+        _localPortRTCP = _localPort + 1;
+        WEBRTC_TRACE(
+            kTraceStateInfo,
+            kTraceTransport,
+            _id,
+            "InitializeReceiveSockets RTCP port not configured using RTP\
+ port+1=%d",
+            _localPortRTCP);
+    }
+
+    if(ip)
+    {
+        if(IsIpAddressValid(ip,IpV6Enabled()))
+        {
+            strncpy(_localIP, ip,kIpAddressVersion6Length);
+        } else
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "InitializeReceiveSockets invalid IP address");
+            _lastError = kIpAddressInvalid;
+            return -1;
+        }
+    }else
+    {
+        // Don't bind to a specific IP address.
+        if(! IpV6Enabled())
+        {
+            strncpy(_localIP, "0.0.0.0",16);
+        } else
+        {
+            strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
+                    kIpAddressVersion6Length);
+        }
+    }
+    if(multicastIpAddr && !IpV6Enabled())
+    {
+        if(IsIpAddressValid(multicastIpAddr,IpV6Enabled()))
+        {
+            strncpy(_localMulticastIP, multicastIpAddr,
+                    kIpAddressVersion6Length);
+        } else
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "InitializeReceiveSockets invalid IP address");
+            _lastError =  kIpAddressInvalid;
+            return -1;
+        }
+    }
+    if(_mgr == NULL)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "InitializeReceiveSockets no socket manager");
+        return -1;
+    }
+
+    _useSetSockOpt=false;
+    _tos=0;
+    _pcp=0;
+
+    _ptrRtpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
+                                    IncomingRTPCallback,
+                                    IpV6Enabled(), false);
+
+    _ptrRtcpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
+                                     IncomingRTCPCallback,
+                                     IpV6Enabled(), false);
+
+    ErrorCode retVal = BindLocalRTPSocket();
+    if(retVal != kNoSocketError)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "InitializeReceiveSockets faild to bind RTP socket");
+        _lastError = retVal;
+        CloseReceiveSockets();
+        return -1;
+    }
+    retVal = BindLocalRTCPSocket();
+    if(retVal != kNoSocketError)
+    {
+        _lastError = retVal;
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "InitializeReceiveSockets faild to bind RTCP socket");
+        CloseReceiveSockets();
+        return -1;
+    }
+    return 0;
+}
+
+int32_t UdpTransportImpl::ReceiveSocketInformation(
+    char ipAddr[kIpAddressVersion6Length],
+    uint16_t& rtpPort,
+    uint16_t& rtcpPort,
+    char multicastIpAddr[kIpAddressVersion6Length]) const
+{
+    CriticalSectionScoped cs(_crit);
+    rtpPort = _localPort;
+    rtcpPort = _localPortRTCP;
+    if (ipAddr)
+    {
+        strncpy(ipAddr, _localIP, IpV6Enabled() ?
+                UdpTransport::kIpAddressVersion6Length :
+                UdpTransport::kIpAddressVersion4Length);
+    }
+    if (multicastIpAddr)
+    {
+        strncpy(multicastIpAddr, _localMulticastIP, IpV6Enabled() ?
+                UdpTransport::kIpAddressVersion6Length :
+                UdpTransport::kIpAddressVersion4Length);
+    }
+    return 0;
+}
+
+int32_t UdpTransportImpl::SendSocketInformation(
+    char ipAddr[kIpAddressVersion6Length],
+    uint16_t& rtpPort,
+    uint16_t& rtcpPort) const
+{
+    CriticalSectionScoped cs(_crit);
+    rtpPort = _destPort;
+    rtcpPort = _destPortRTCP;
+    strncpy(ipAddr, _destIP, IpV6Enabled() ?
+            UdpTransport::kIpAddressVersion6Length :
+            UdpTransport::kIpAddressVersion4Length);
+    return 0;
+}
+
+int32_t UdpTransportImpl::RemoteSocketInformation(
+    char ipAddr[kIpAddressVersion6Length],
+    uint16_t& rtpPort,
+    uint16_t& rtcpPort) const
+{
+    CriticalSectionScoped cs(_crit);
+    rtpPort = _fromPort;
+    rtcpPort = _fromPortRTCP;
+    if(ipAddr)
+    {
+        strncpy(ipAddr, _fromIP, IpV6Enabled() ?
+                kIpAddressVersion6Length :
+                kIpAddressVersion4Length);
+    }
+    return 0;
+}
+
+int32_t UdpTransportImpl::FilterPorts(
+    uint16_t& rtpFilterPort,
+    uint16_t& rtcpFilterPort) const
+{
+    CriticalSectionScoped cs(_critFilter);
+    rtpFilterPort = _rtpFilterPort;
+    rtcpFilterPort = _rtcpFilterPort;
+    return 0;
+}
+
+int32_t UdpTransportImpl::SetQoS(bool QoS, int32_t serviceType,
+                                 uint32_t maxBitrate,
+                                 int32_t overrideDSCP, bool audio)
+{
+    if(QoS)
+    {
+        return EnableQoS(serviceType, audio, maxBitrate, overrideDSCP);
+    }else
+    {
+        return DisableQoS();
+    }
+}
+
+int32_t UdpTransportImpl::EnableQoS(int32_t serviceType,
+                                    bool audio, uint32_t maxBitrate,
+                                    int32_t overrideDSCP)
+{
+    if (_ipV6Enabled)
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but will be ignored since IPv6 is enabled");
+        _lastError = kQosError;
+        return -1;
+    }
+    if (_tos)
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "TOS already enabled, can't use TOS and QoS at the same time");
+        _lastError = kQosError;
+        return -1;
+    }
+    if (_pcp)
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "PCP already enabled, can't use PCP and QoS at the same time");
+        _lastError = kQosError;
+        return -1;
+    }
+    if(_destPort == 0)
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but not started since we have not yet configured\
+ the send destination");
+        return -1;
+    }
+    if(_qos)
+    {
+        if(_overrideDSCP == 0 && overrideDSCP != 0)
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "QOS is already enabled and overrideDSCP differs, not allowed");
+            return -1;
+        }
+    }
+    CriticalSectionScoped cs(_crit);
+
+    UdpSocketWrapper* rtpSock = _ptrSendRtpSocket ?
+        _ptrSendRtpSocket :
+        _ptrRtpSocket;
+    if (!rtpSock || !rtpSock->ValidHandle())
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but not started since we have not yet created the\
+ RTP socket");
+        return -1;
+    }
+    UdpSocketWrapper* rtcpSock = _ptrSendRtcpSocket ?
+        _ptrSendRtcpSocket :
+        _ptrRtcpSocket;
+    if (!rtcpSock || !rtcpSock->ValidHandle())
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but not started since we have not yet created the\
+ RTCP socket");
+        return -1;
+    }
+
+    // Minimum packet size in bytes for which the requested quality of service
+    // will be provided. The smallest RTP header is 12 byte.
+    const int32_t min_policed_size = 12;
+    // Max SDU, maximum packet size permitted or used in the traffic flow, in
+    // bytes.
+    const int32_t max_sdu_size = 1500;
+
+    // Enable QoS for RTP sockets.
+    if(maxBitrate)
+    {
+        // Note: 1 kbit is 125 bytes.
+        // Token Rate is typically set to the average bit rate from peak to
+        // peak.
+        // Bucket size is normally set to the largest average frame size.
+        if(audio)
+        {
+            WEBRTC_TRACE(kTraceStateInfo,
+                         kTraceTransport,
+                         _id,
+                         "Enable QOS for audio with max bitrate:%d",
+                         maxBitrate);
+
+            const int32_t token_rate = maxBitrate*125;
+            // The largest audio packets are 60ms frames. This is a fraction
+            // more than 16 packets/second. These 16 frames are sent, at max,
+            // at a bitrate of maxBitrate*125 -> 1 frame is maxBitrate*125/16 ~
+            // maxBitrate * 8.
+            const int32_t bucket_size = maxBitrate * 8;
+            const int32_t peek_bandwith =  maxBitrate * 125;
+            if (!rtpSock->SetQos(serviceType, token_rate, bucket_size,
+                                 peek_bandwith, min_policed_size,
+                                 max_sdu_size, _remoteRTPAddr, overrideDSCP))
+            {
+                WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                             "QOS failed on the RTP socket");
+                _lastError = kQosError;
+                return -1;
+            }
+        }else
+        {
+            WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                         "Enable QOS for video with max bitrate:%d",
+                         maxBitrate);
+
+            // Allow for a token rate that is twice that of the maximum bitrate
+            // (in bytes).
+            const int32_t token_rate = maxBitrate*250;
+            // largest average frame size (key frame size). Assuming that a
+            // keyframe is 25% of the bitrate during the second its sent
+            // Assume that a key frame is 25% of the bitrate the second that it
+            // is sent. The largest frame size is then maxBitrate* 125 * 0.25 ~
+            // 31.
+            const int32_t bucket_size = maxBitrate*31;
+            const int32_t peek_bandwith = maxBitrate*125;
+            if (!rtpSock->SetQos(serviceType, token_rate, bucket_size,
+                                peek_bandwith, min_policed_size, max_sdu_size,
+                                _remoteRTPAddr, overrideDSCP))
+            {
+                WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                             "QOS failed on the RTP socket");
+                _lastError = kQosError;
+                return -1;
+            }
+        }
+    } else if(audio)
+    {
+        // No max bitrate set. Audio.
+        WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                     "Enable QOS for audio with default max bitrate");
+
+        // Let max bitrate be 240kbit/s.
+        const int32_t token_rate = 30000;
+        const int32_t bucket_size = 2000;
+        const int32_t peek_bandwith = 30000;
+        if (!rtpSock->SetQos(serviceType, token_rate, bucket_size,
+                             peek_bandwith, min_policed_size, max_sdu_size,
+                             _remoteRTPAddr, overrideDSCP))
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "QOS failed on the RTP socket");
+            _lastError = kQosError;
+            return -1;
+        }
+    }else
+    {
+        // No max bitrate set. Video.
+        WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                     "Enable QOS for video with default max bitrate");
+
+        // Let max bitrate be 10mbit/s.
+        const int32_t token_rate = 128000*10;
+        const int32_t bucket_size = 32000;
+        const int32_t peek_bandwith = 256000;
+        if (!rtpSock->SetQos(serviceType, token_rate, bucket_size,
+                             peek_bandwith, min_policed_size, max_sdu_size,
+                             _remoteRTPAddr, overrideDSCP))
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "QOS failed on the RTP socket");
+            _lastError = kQosError;
+            return -1;
+        }
+    }
+
+    // Enable QoS for RTCP sockets.
+    // TODO (hellner): shouldn't RTCP be based on 5% of the maximum bandwidth?
+    if(audio)
+    {
+        const int32_t token_rate = 200;
+        const int32_t bucket_size = 200;
+        const int32_t peek_bandwith = 400;
+        if (!rtcpSock->SetQos(serviceType, token_rate, bucket_size,
+                              peek_bandwith, min_policed_size, max_sdu_size,
+                              _remoteRTCPAddr, overrideDSCP))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "QOS failed on the RTCP socket");
+            _lastError = kQosError;
+        }
+    }else
+    {
+        const int32_t token_rate = 5000;
+        const int32_t bucket_size = 100;
+        const int32_t peek_bandwith = 10000;
+        if (!rtcpSock->SetQos(serviceType, token_rate, bucket_size,
+                              peek_bandwith, min_policed_size, max_sdu_size,
+                            _remoteRTCPAddr, _overrideDSCP))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "QOS failed on the RTCP socket");
+            _lastError = kQosError;
+        }
+    }
+    _qos = true;
+    _serviceType = serviceType;
+    _maxBitrate = maxBitrate;
+    _overrideDSCP = overrideDSCP;
+    return 0;
+}
+
+int32_t UdpTransportImpl::DisableQoS()
+{
+    if(_qos == false)
+    {
+        return 0;
+    }
+    CriticalSectionScoped cs(_crit);
+
+    UdpSocketWrapper* rtpSock = (_ptrSendRtpSocket ?
+                                 _ptrSendRtpSocket : _ptrRtpSocket);
+    if (!rtpSock || !rtpSock->ValidHandle())
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but not started since we have not yet created the\
+ RTP socket");
+        return -1;
+    }
+    UdpSocketWrapper* rtcpSock = (_ptrSendRtcpSocket ?
+                                  _ptrSendRtcpSocket : _ptrRtcpSocket);
+    if (!rtcpSock || !rtcpSock->ValidHandle())
+    {
+        WEBRTC_TRACE(
+            kTraceError,
+            kTraceTransport,
+            _id,
+            "QOS is enabled but not started since we have not yet created the\
+ RTCP socket");
+        return -1;
+    }
+
+    const int32_t service_type = 0;   // = SERVICETYPE_NOTRAFFIC
+    const int32_t not_specified = -1;
+    if (!rtpSock->SetQos(service_type, not_specified, not_specified,
+                         not_specified, not_specified, not_specified,
+                         _remoteRTPAddr, _overrideDSCP))
+    {
+        _lastError = kQosError;
+        return -1;
+    }
+    if (!rtcpSock->SetQos(service_type, not_specified, not_specified,
+                         not_specified, not_specified, not_specified,
+                         _remoteRTCPAddr,_overrideDSCP))
+    {
+        _lastError = kQosError;
+    }
+    _qos = false;
+    return 0;
+}
+
+int32_t UdpTransportImpl::QoS(bool& QoS, int32_t& serviceType,
+                              int32_t& overrideDSCP) const
+{
+    CriticalSectionScoped cs(_crit);
+    QoS = _qos;
+    serviceType = _serviceType;
+    overrideDSCP = _overrideDSCP;
+    return 0;
+}
+
+int32_t UdpTransportImpl::SetToS(int32_t DSCP, bool useSetSockOpt)
+{
+    if (_qos)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "QoS already enabled");
+        _lastError = kQosError;
+        return -1;
+    }
+    if (DSCP < 0 || DSCP > 63)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "Invalid DSCP");
+        _lastError = kTosInvalid;
+        return -1;
+    }
+    if(_tos)
+    {
+        if(useSetSockOpt != _useSetSockOpt)
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "Can't switch SetSockOpt method without disabling TOS first");
+            _lastError = kTosInvalid;
+            return -1;
+        }
+    }
+    CriticalSectionScoped cs(_crit);
+    UdpSocketWrapper* rtpSock = NULL;
+    UdpSocketWrapper* rtcpSock = NULL;
+    if(_ptrSendRtpSocket)
+    {
+        rtpSock = _ptrSendRtpSocket;
+    }else
+    {
+        rtpSock = _ptrRtpSocket;
+    }
+    if (rtpSock == NULL)
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(!rtpSock->ValidHandle())
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(_ptrSendRtcpSocket)
+    {
+        rtcpSock = _ptrSendRtcpSocket;
+    }else
+    {
+        rtcpSock = _ptrRtcpSocket;
+    }
+    if (rtcpSock == NULL)
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(!rtcpSock->ValidHandle())
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+
+    if (useSetSockOpt)
+    {
+#ifdef _WIN32
+        OSVERSIONINFO OsVersion;
+        OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        GetVersionEx(&OsVersion);
+        // Disable QoS before setting ToS on Windows XP. This is done by closing
+        // and re-opening the sockets.
+        // TODO (hellner): why not just fail here and force the user to
+        //                 re-initialize sockets? Doing this may trick the user
+        //                 into thinking that the sockets are in a state which
+        //                 they aren't.
+        if (OsVersion.dwMajorVersion == 5 &&
+            OsVersion.dwMinorVersion == 1)
+        {
+            if(!_useSetSockOpt)
+            {
+                if(_ptrSendRtpSocket)
+                {
+                    CloseSendSockets();
+                    _ptrSendRtpSocket =
+                        _socket_creator->CreateSocket(_id, _mgr, NULL,
+                                        NULL, IpV6Enabled(),
+                                        true);
+                    _ptrSendRtcpSocket =
+                        _socket_creator->CreateSocket(_id, _mgr, NULL,
+                                        NULL, IpV6Enabled(),
+                                        true);
+                    rtpSock=_ptrSendRtpSocket;
+                    rtcpSock=_ptrSendRtcpSocket;
+                    ErrorCode retVal = BindRTPSendSocket();
+                    if(retVal != kNoSocketError)
+                    {
+                        _lastError = retVal;
+                        return -1;
+                    }
+                    retVal = BindRTCPSendSocket();
+                    if(retVal != kNoSocketError)
+                    {
+                        _lastError = retVal;
+                        return -1;
+                    }
+                }
+                else
+                {
+                    bool receiving=_receiving;
+                    uint32_t noOfReceiveBuffers = 0;
+                    if(receiving)
+                    {
+                        noOfReceiveBuffers=_ptrRtpSocket->ReceiveBuffers();
+                        if(StopReceiving()!=0)
+                        {
+                            return -1;
+                        }
+                    }
+                    CloseReceiveSockets();
+                    _ptrRtpSocket = _socket_creator->CreateSocket(
+                        _id, _mgr, this, IncomingRTPCallback, IpV6Enabled(),
+                        true);
+                    _ptrRtcpSocket = _socket_creator->CreateSocket(
+                        _id, _mgr, this, IncomingRTCPCallback, IpV6Enabled(),
+                        true);
+                    rtpSock=_ptrRtpSocket;
+                    rtcpSock=_ptrRtcpSocket;
+                    ErrorCode retVal = BindLocalRTPSocket();
+                    if(retVal != kNoSocketError)
+                    {
+                        _lastError = retVal;
+                        return -1;
+                    }
+                    retVal = BindLocalRTCPSocket();
+                    if(retVal != kNoSocketError)
+                    {
+                        _lastError = retVal;
+                        return -1;
+                    }
+                    if(receiving)
+                    {
+                        if(StartReceiving(noOfReceiveBuffers) !=
+                           kNoSocketError)
+                        {
+                            return -1;
+                        }
+                    }
+                }
+            }
+        }
+#endif // #ifdef _WIN32
+        WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
+                     "Setting TOS using SetSockopt");
+        int32_t TOSShifted = DSCP << 2;
+        if (!rtpSock->SetSockopt(IPPROTO_IP, IP_TOS,
+                                 (int8_t*) &TOSShifted, 4))
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Could not SetSockopt tos value on RTP socket");
+            _lastError = kTosInvalid;
+            return -1;
+        }
+        if (!rtcpSock->SetSockopt(IPPROTO_IP, IP_TOS,
+                                  (int8_t*) &TOSShifted, 4))
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Could not sSetSockopt tos value on RTCP socket");
+            _lastError = kTosInvalid;
+            return -1;
+        }
+    } else
+    {
+        WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
+                     "Setting TOS NOT using SetSockopt");
+        if (rtpSock->SetTOS(DSCP) != 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Could not set tos value on RTP socket");
+            _lastError = kTosError;
+            return -1;
+        }
+        if (rtcpSock->SetTOS(DSCP) != 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Could not set tos value on RTCP socket");
+            _lastError = kTosError;
+            return -1;
+        }
+    }
+    _useSetSockOpt = useSetSockOpt;
+    _tos = DSCP;
+    return 0;
+}
+
+int32_t UdpTransportImpl::ToS(int32_t& DSCP,
+                              bool& useSetSockOpt) const
+{
+    CriticalSectionScoped cs(_crit);
+    DSCP = _tos;
+    useSetSockOpt = _useSetSockOpt;
+    return 0;
+}
+
+int32_t UdpTransportImpl::SetPCP(int32_t PCP)
+{
+
+    if (_qos)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "QoS already enabled");
+        _lastError = kQosError;
+        return -1;
+    }
+    if ((PCP < 0) || (PCP > 7))
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "Invalid PCP");
+        _lastError = kPcpError;
+        return -1;
+    }
+
+    CriticalSectionScoped cs(_crit);
+    UdpSocketWrapper* rtpSock = NULL;
+    UdpSocketWrapper* rtcpSock = NULL;
+    if(_ptrSendRtpSocket)
+    {
+        rtpSock = _ptrSendRtpSocket;
+    }else
+    {
+        rtpSock = _ptrRtpSocket;
+    }
+    if (rtpSock == NULL)
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(!rtpSock->ValidHandle())
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(_ptrSendRtcpSocket)
+    {
+        rtcpSock = _ptrSendRtcpSocket;
+    }else
+    {
+        rtcpSock = _ptrRtcpSocket;
+    }
+    if (rtcpSock == NULL)
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+    if(!rtcpSock->ValidHandle())
+    {
+        _lastError = kSocketInvalid;
+        return -1;
+    }
+
+#if defined(_WIN32)
+    if (rtpSock->SetPCP(PCP) != 0)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "Could not set PCP value on RTP socket");
+        _lastError = kPcpError;
+        return -1;
+    }
+    if (rtcpSock->SetPCP(PCP) != 0)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "Could not set PCP value on RTCP socket");
+        _lastError = kPcpError;
+        return -1;
+    }
+
+#elif defined(WEBRTC_LINUX)
+    if (!rtpSock->SetSockopt(SOL_SOCKET, SO_PRIORITY, (int8_t*) &PCP,
+                             sizeof(PCP)))
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "Could not SetSockopt PCP value on RTP socket");
+        _lastError = kPcpError;
+        return -1;
+    }
+    if (!rtcpSock->SetSockopt(SOL_SOCKET, SO_PRIORITY, (int8_t*) &PCP,
+                              sizeof(PCP)))
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "Could not SetSockopt PCP value on RTCP socket");
+        _lastError = kPcpError;
+        return -1;
+    }
+#else
+    // Not supported on other platforms (WEBRTC_MAC)
+    _lastError = kPcpError;
+    return -1;
+#endif
+    _pcp = PCP;
+    return 0;
+}
+
+int32_t UdpTransportImpl::PCP(int32_t& PCP) const
+{
+    CriticalSectionScoped cs(_crit);
+    PCP = _pcp;
+    return 0;
+}
+
+bool UdpTransportImpl::SetSockOptUsed()
+{
+    return _useSetSockOpt;
+}
+
+int32_t UdpTransportImpl::EnableIpV6() {
+
+  CriticalSectionScoped cs(_crit);
+  const bool initialized = (_ptrSendRtpSocket || _ptrRtpSocket);
+
+  if (_ipV6Enabled) {
+    return 0;
+  }
+  if (initialized) {
+    _lastError = kIpVersion6Error;
+    return -1;
+  }
+  _ipV6Enabled = true;
+  return 0;
+}
+
+int32_t UdpTransportImpl::FilterIP(
+    char filterIPAddress[kIpAddressVersion6Length]) const
+{
+
+    if(filterIPAddress == NULL)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "FilterIP: Invalid argument");
+        return -1;
+    }
+    if(_filterIPAddress._sockaddr_storage.sin_family == 0)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "No Filter configured");
+        return -1;
+    }
+    CriticalSectionScoped cs(_critFilter);
+    uint32_t ipSize = kIpAddressVersion6Length;
+    uint16_t sourcePort;
+    return IPAddress(_filterIPAddress, filterIPAddress, ipSize, sourcePort);
+}
+
+int32_t UdpTransportImpl::SetFilterIP(
+    const char filterIPAddress[kIpAddressVersion6Length])
+{
+    if(filterIPAddress == NULL)
+    {
+        memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
+        WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id, "Filter IP reset");
+        return 0;
+    }
+    CriticalSectionScoped cs(_critFilter);
+    if (_ipV6Enabled)
+    {
+        _filterIPAddress._sockaddr_storage.sin_family = AF_INET6;
+
+        if (InetPresentationToNumeric(
+                AF_INET6,
+                filterIPAddress,
+                &_filterIPAddress._sockaddr_in6.sin6_addr) < 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "Failed to set\
+ filter IP for IPv6");
+            _lastError = FILTER_ERROR;
+            return -1;
+        }
+    }
+    else
+    {
+        _filterIPAddress._sockaddr_storage.sin_family = AF_INET;
+
+        if(InetPresentationToNumeric(
+               AF_INET,
+               filterIPAddress,
+               &_filterIPAddress._sockaddr_in.sin_addr) < 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Failed to set filter IP for IPv4");
+            _lastError = FILTER_ERROR;
+            return -1;
+        }
+    }
+    WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id, "Filter IP set");
+    return 0;
+}
+
+int32_t UdpTransportImpl::SetFilterPorts(uint16_t rtpFilterPort,
+                                         uint16_t rtcpFilterPort)
+{
+    CriticalSectionScoped cs(_critFilter);
+    _rtpFilterPort = rtpFilterPort;
+    _rtcpFilterPort = rtcpFilterPort;
+    return 0;
+}
+
+bool UdpTransportImpl::SendSocketsInitialized() const
+{
+    CriticalSectionScoped cs(_crit);
+    if(_ptrSendRtpSocket)
+    {
+        return true;
+    }
+    if(_destPort !=0)
+    {
+        return true;
+    }
+    return false;
+}
+
+bool UdpTransportImpl::ReceiveSocketsInitialized() const
+{
+    if(_ptrRtpSocket)
+    {
+        return true;
+    }
+    return false;
+}
+
+bool UdpTransportImpl::SourcePortsInitialized() const
+{
+    if(_ptrSendRtpSocket)
+    {
+        return true;
+    }
+    return false;
+}
+
+bool UdpTransportImpl::IpV6Enabled() const
+{
+    WEBRTC_TRACE(kTraceStream, kTraceTransport, _id, "%s", __FUNCTION__);
+    return _ipV6Enabled;
+}
+
+void UdpTransportImpl::BuildRemoteRTPAddr()
+{
+    if(_ipV6Enabled)
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _remoteRTPAddr.sin_length = 0;
+        _remoteRTPAddr.sin_family = PF_INET6;
+#else
+        _remoteRTPAddr._sockaddr_storage.sin_family = PF_INET6;
+#endif
+
+        _remoteRTPAddr._sockaddr_in6.sin6_flowinfo=0;
+        _remoteRTPAddr._sockaddr_in6.sin6_scope_id=0;
+        _remoteRTPAddr._sockaddr_in6.sin6_port = Htons(_destPort);
+        InetPresentationToNumeric(AF_INET6,_destIP,
+                                  &_remoteRTPAddr._sockaddr_in6.sin6_addr);
+    } else
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _remoteRTPAddr.sin_length = 0;
+        _remoteRTPAddr.sin_family = PF_INET;
+#else
+        _remoteRTPAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        _remoteRTPAddr._sockaddr_in.sin_port = Htons(_destPort);
+        _remoteRTPAddr._sockaddr_in.sin_addr = InetAddrIPV4(_destIP);
+    }
+}
+
+void UdpTransportImpl::BuildRemoteRTCPAddr()
+{
+    if(_ipV6Enabled)
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _remoteRTCPAddr.sin_length = 0;
+        _remoteRTCPAddr.sin_family = PF_INET6;
+#else
+        _remoteRTCPAddr._sockaddr_storage.sin_family = PF_INET6;
+#endif
+
+        _remoteRTCPAddr._sockaddr_in6.sin6_flowinfo=0;
+        _remoteRTCPAddr._sockaddr_in6.sin6_scope_id=0;
+        _remoteRTCPAddr._sockaddr_in6.sin6_port = Htons(_destPortRTCP);
+        InetPresentationToNumeric(AF_INET6,_destIP,
+                                  &_remoteRTCPAddr._sockaddr_in6.sin6_addr);
+
+    } else
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _remoteRTCPAddr.sin_length = 0;
+        _remoteRTCPAddr.sin_family = PF_INET;
+#else
+        _remoteRTCPAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        _remoteRTCPAddr._sockaddr_in.sin_port = Htons(_destPortRTCP);
+        _remoteRTCPAddr._sockaddr_in.sin_addr= InetAddrIPV4(_destIP);
+    }
+}
+
+UdpTransportImpl::ErrorCode UdpTransportImpl::BindRTPSendSocket()
+{
+    if(!_ptrSendRtpSocket)
+    {
+        return kSocketInvalid;
+    }
+    if(!_ptrSendRtpSocket->ValidHandle())
+    {
+        return kIpAddressInvalid;
+    }
+    if(_ipV6Enabled)
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _localRTPAddr.sin_length = 0;
+        _localRTPAddr.sin_family = PF_INET6;
+#else
+        _localRTPAddr._sockaddr_storage.sin_family = PF_INET6;
+#endif
+        _localRTPAddr._sockaddr_in6.sin6_flowinfo=0;
+        _localRTPAddr._sockaddr_in6.sin6_scope_id=0;
+        _localRTPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[0] =
+            0; // = INADDR_ANY
+        _localRTPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[1] =
+            0;
+        _localRTPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[2] =
+            0;
+        _localRTPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[3] =
+            0;
+        _localRTPAddr._sockaddr_in6.sin6_port = Htons(_srcPort);
+        if(_ptrSendRtpSocket->Bind(_localRTPAddr) == false)
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _srcPort);
+            return kFailedToBindPort;
+        }
+
+    } else {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _localRTPAddr.sin_length = 0;
+        _localRTPAddr.sin_family = PF_INET;
+#else
+        _localRTPAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        _localRTPAddr._sockaddr_in.sin_addr = 0;
+        _localRTPAddr._sockaddr_in.sin_port = Htons(_srcPort);
+        if(_ptrSendRtpSocket->Bind(_localRTPAddr) == false)
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _srcPort);
+            return kFailedToBindPort;
+        }
+    }
+    return kNoSocketError;
+}
+
+UdpTransportImpl::ErrorCode UdpTransportImpl::BindRTCPSendSocket()
+{
+    if(!_ptrSendRtcpSocket)
+    {
+        return kSocketInvalid;
+    }
+
+    if(_ipV6Enabled)
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _localRTCPAddr.sin_length = 0;
+        _localRTCPAddr.sin_family = PF_INET6;
+#else
+        _localRTCPAddr._sockaddr_storage.sin_family = PF_INET6;
+#endif
+        _localRTCPAddr._sockaddr_in6.sin6_flowinfo=0;
+        _localRTCPAddr._sockaddr_in6.sin6_scope_id=0;
+        _localRTCPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[0] =
+            0; // = INADDR_ANY
+        _localRTCPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[1] =
+            0;
+        _localRTCPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[2] =
+            0;
+        _localRTCPAddr._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[3] =
+            0;
+        _localRTCPAddr._sockaddr_in6.sin6_port = Htons(_srcPortRTCP);
+        if(_ptrSendRtcpSocket->Bind(_localRTCPAddr) == false)
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _srcPortRTCP);
+            return kFailedToBindPort;
+        }
+    } else {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        _localRTCPAddr.sin_length = 0;
+        _localRTCPAddr.sin_family = PF_INET;
+#else
+        _localRTCPAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        _localRTCPAddr._sockaddr_in.sin_addr= 0;
+        _localRTCPAddr._sockaddr_in.sin_port = Htons(_srcPortRTCP);
+        if(_ptrSendRtcpSocket->Bind(_localRTCPAddr) == false)
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _srcPortRTCP);
+            return kFailedToBindPort;
+        }
+    }
+    return kNoSocketError;
+}
+
+UdpTransportImpl::ErrorCode UdpTransportImpl::BindLocalRTPSocket()
+{
+    if(!_ptrRtpSocket)
+    {
+        return kSocketInvalid;
+    }
+    if(!IpV6Enabled())
+    {
+        SocketAddress recAddr;
+        memset(&recAddr, 0, sizeof(SocketAddress));
+        recAddr._sockaddr_storage.sin_family = AF_INET;
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        recAddr.sin_length = 0;
+        recAddr.sin_family = PF_INET;
+#else
+        recAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        recAddr._sockaddr_in.sin_addr = InetAddrIPV4(_localIP);
+        recAddr._sockaddr_in.sin_port = Htons(_localPort);
+
+        if (!_ptrRtpSocket->Bind(recAddr))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _localPort);
+            return kFailedToBindPort;
+        }
+    }
+    else
+    {
+        SocketAddress stLclName;
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        stLclName.sin_lenght = 0;
+        stLclName.sin_family = PF_INET6;
+#else
+        stLclName._sockaddr_storage.sin_family = PF_INET6;
+#endif
+        InetPresentationToNumeric(AF_INET6,_localIP,
+                                  &stLclName._sockaddr_in6.sin6_addr);
+        stLclName._sockaddr_in6.sin6_port = Htons(_localPort);
+        stLclName._sockaddr_in6.sin6_flowinfo = 0;
+        stLclName._sockaddr_in6.sin6_scope_id = 0;
+
+        if (!_ptrRtpSocket->Bind(stLclName))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _localPort);
+            return kFailedToBindPort;
+        }
+    }
+
+    if(_localMulticastIP[0] != 0)
+    {
+        // Join the multicast group from which to receive datagrams.
+        struct ip_mreq mreq;
+        mreq.imr_multiaddr.s_addr = InetAddrIPV4(_localMulticastIP);
+        mreq.imr_interface.s_addr = INADDR_ANY;
+
+        if (!_ptrRtpSocket->SetSockopt(IPPROTO_IP,IP_ADD_MEMBERSHIP,
+                                       (int8_t*)&mreq,sizeof (mreq)))
+        {
+           WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "setsockopt() for multicast failed, not closing socket");
+        }else
+        {
+            WEBRTC_TRACE(kTraceInfo, kTraceTransport, _id,
+                         "multicast group successfully joined");
+        }
+    }
+    return kNoSocketError;
+}
+
+UdpTransportImpl::ErrorCode UdpTransportImpl::BindLocalRTCPSocket()
+{
+    if(!_ptrRtcpSocket)
+    {
+        return kSocketInvalid;
+    }
+    if(! IpV6Enabled())
+    {
+        SocketAddress recAddr;
+        memset(&recAddr, 0, sizeof(SocketAddress));
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        recAddr.sin_length = 0;
+        recAddr.sin_family = AF_INET;
+#else
+        recAddr._sockaddr_storage.sin_family = AF_INET;
+#endif
+        recAddr._sockaddr_in.sin_addr = InetAddrIPV4(_localIP);
+        recAddr._sockaddr_in.sin_port = Htons(_localPortRTCP);
+
+        if (!_ptrRtcpSocket->Bind(recAddr))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _localPortRTCP);
+            return kFailedToBindPort;
+        }
+    }
+    else
+    {
+        SocketAddress stLclName;
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        stLclName.sin_length = 0;
+        stLclName.sin_family = PF_INET6;
+#else
+        stLclName._sockaddr_storage.sin_family = PF_INET6;
+#endif
+        stLclName._sockaddr_in6.sin6_flowinfo = 0;
+        stLclName._sockaddr_in6.sin6_scope_id = 0;
+        stLclName._sockaddr_in6.sin6_port = Htons(_localPortRTCP);
+
+        InetPresentationToNumeric(AF_INET6,_localIP,
+                                  &stLclName._sockaddr_in6.sin6_addr);
+        if (!_ptrRtcpSocket->Bind(stLclName))
+        {
+            WEBRTC_TRACE(kTraceWarning, kTraceTransport, _id,
+                         "Failed to bind to port:%d ", _localPortRTCP);
+            return kFailedToBindPort;
+        }
+    }
+    if(_localMulticastIP[0] != 0)
+    {
+        // Join the multicast group from which to receive datagrams.
+        struct ip_mreq mreq;
+        mreq.imr_multiaddr.s_addr = InetAddrIPV4(_localMulticastIP);
+        mreq.imr_interface.s_addr = INADDR_ANY;
+
+        if (!_ptrRtcpSocket->SetSockopt(IPPROTO_IP,IP_ADD_MEMBERSHIP,
+                                        (int8_t*)&mreq,sizeof (mreq)))
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "setsockopt() for multicast failed, not closing socket");
+        }else
+        {
+            WEBRTC_TRACE(kTraceInfo, kTraceTransport, _id,
+                         "multicast group successfully joined");
+        }
+    }
+    return kNoSocketError;
+}
+
+int32_t UdpTransportImpl::InitializeSourcePorts(uint16_t rtpPort,
+                                                uint16_t rtcpPort)
+{
+
+    if(rtpPort == 0)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "InitializeSourcePorts port 0 not allowed");
+        _lastError = kPortInvalid;
+        return -1;
+    }
+
+    CriticalSectionScoped cs(_crit);
+
+    CloseSendSockets();
+
+    if(_mgr == NULL)
+    {
+        return -1;
+    }
+
+    _srcPort = rtpPort;
+    if(rtcpPort == 0)
+    {
+        _srcPortRTCP = rtpPort+1;
+    } else
+    {
+        _srcPortRTCP = rtcpPort;
+    }
+    _useSetSockOpt =false;
+    _tos=0;
+    _pcp=0;
+
+    _ptrSendRtpSocket = _socket_creator->CreateSocket(_id, _mgr, NULL, NULL,
+                                        IpV6Enabled(), false);
+    _ptrSendRtcpSocket = _socket_creator->CreateSocket(_id, _mgr, NULL, NULL,
+                                         IpV6Enabled(), false);
+
+    ErrorCode retVal = BindRTPSendSocket();
+    if(retVal != kNoSocketError)
+    {
+        _lastError = retVal;
+        return -1;
+    }
+    retVal = BindRTCPSendSocket();
+    if(retVal != kNoSocketError)
+    {
+        _lastError = retVal;
+        return -1;
+    }
+    return 0;
+}
+
+int32_t UdpTransportImpl::SourcePorts(uint16_t& rtpPort,
+                                      uint16_t& rtcpPort) const
+{
+    CriticalSectionScoped cs(_crit);
+
+    rtpPort  = (_srcPort != 0) ? _srcPort : _localPort;
+    rtcpPort = (_srcPortRTCP != 0) ? _srcPortRTCP : _localPortRTCP;
+    return 0;
+}
+
+
+#ifdef _WIN32
+int32_t UdpTransportImpl::StartReceiving(uint32_t numberOfSocketBuffers)
+#else
+int32_t UdpTransportImpl::StartReceiving(uint32_t /*numberOfSocketBuffers*/)
+#endif
+{
+    CriticalSectionScoped cs(_crit);
+    if(_receiving)
+    {
+        return 0;
+    }
+    if(_ptrRtpSocket)
+    {
+#ifdef _WIN32
+        if(!_ptrRtpSocket->StartReceiving(numberOfSocketBuffers))
+#else
+        if(!_ptrRtpSocket->StartReceiving())
+#endif
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Failed to start receive on RTP socket");
+            _lastError = kStartReceiveError;
+            return -1;
+        }
+    }
+    if(_ptrRtcpSocket)
+    {
+        if(!_ptrRtcpSocket->StartReceiving())
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Failed to start receive on RTCP socket");
+            _lastError = kStartReceiveError;
+            return -1;
+        }
+    }
+    if( _ptrRtpSocket == NULL &&
+        _ptrRtcpSocket == NULL)
+    {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "Failed to StartReceiving, no socket initialized");
+        _lastError = kStartReceiveError;
+        return -1;
+    }
+    _receiving = true;
+    return 0;
+}
+
+bool UdpTransportImpl::Receiving() const
+{
+   return _receiving;
+}
+
+int32_t UdpTransportImpl::StopReceiving()
+{
+
+    CriticalSectionScoped cs(_crit);
+
+    _receiving = false;
+
+    if (_ptrRtpSocket)
+    {
+        if (!_ptrRtpSocket->StopReceiving())
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Failed to stop receiving on RTP socket");
+            _lastError = kStopReceiveError;
+            return -1;
+        }
+    }
+    if (_ptrRtcpSocket)
+    {
+        if (!_ptrRtcpSocket->StopReceiving())
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "Failed to stop receiving on RTCP socket");
+            _lastError = kStopReceiveError;
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int32_t UdpTransportImpl::InitializeSendSockets(
+    const char* ipaddr,
+    const uint16_t rtpPort,
+    const uint16_t rtcpPort)
+{
+    {
+        CriticalSectionScoped cs(_crit);
+        _destPort = rtpPort;
+        if(rtcpPort == 0)
+        {
+            _destPortRTCP = _destPort+1;
+        } else
+        {
+            _destPortRTCP = rtcpPort;
+        }
+
+        if(ipaddr == NULL)
+        {
+            if (!IsIpAddressValid(_destIP, IpV6Enabled()))
+            {
+                _destPort = 0;
+                _destPortRTCP = 0;
+                _lastError = kIpAddressInvalid;
+                return -1;
+            }
+        } else
+        {
+            if (IsIpAddressValid(ipaddr, IpV6Enabled()))
+            {
+                strncpy(
+                    _destIP,
+                    ipaddr,
+                    IpV6Enabled() ? kIpAddressVersion6Length :
+                    kIpAddressVersion4Length);
+            } else {
+                _destPort = 0;
+                _destPortRTCP = 0;
+                _lastError = kIpAddressInvalid;
+                return -1;
+            }
+        }
+        BuildRemoteRTPAddr();
+        BuildRemoteRTCPAddr();
+    }
+
+    if (_ipV6Enabled)
+    {
+        if (_qos)
+        {
+            WEBRTC_TRACE(
+                kTraceWarning,
+                kTraceTransport,
+                _id,
+                "QOS is enabled but will be ignored since IPv6 is enabled");
+        }
+    }else
+    {
+        // TODO (grunell): Multicast support is experimantal.
+
+        // Put the first digit of the remote address in val.
+        int32_t val = ntohl(_remoteRTPAddr._sockaddr_in.sin_addr)>> 24;
+
+        if((val > 223) && (val < 240))
+        {
+            // Multicast address.
+            CriticalSectionScoped cs(_crit);
+
+            UdpSocketWrapper* rtpSock = (_ptrSendRtpSocket ?
+                                         _ptrSendRtpSocket : _ptrRtpSocket);
+            if (!rtpSock || !rtpSock->ValidHandle())
+            {
+                _lastError = kSocketInvalid;
+                return -1;
+            }
+            UdpSocketWrapper* rtcpSock = (_ptrSendRtcpSocket ?
+                                          _ptrSendRtcpSocket : _ptrRtcpSocket);
+            if (!rtcpSock || !rtcpSock->ValidHandle())
+            {
+                _lastError = kSocketInvalid;
+                return -1;
+            }
+
+            // Set Time To Live to same region
+            int32_t iOptVal = 64;
+            if (!rtpSock->SetSockopt(IPPROTO_IP, IP_MULTICAST_TTL,
+                                     (int8_t*)&iOptVal,
+                                     sizeof (int32_t)))
+            {
+                WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                             "setsockopt for multicast error on RTP socket");
+                _ptrRtpSocket->CloseBlocking();
+                _ptrRtpSocket = NULL;
+                _lastError = kMulticastAddressInvalid;
+                return -1;
+            }
+            if (!rtcpSock->SetSockopt(IPPROTO_IP, IP_MULTICAST_TTL,
+                                      (int8_t*)&iOptVal,
+                                      sizeof (int32_t)))
+            {
+                WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                             "setsockopt for multicast error on RTCP socket");
+                _ptrRtpSocket->CloseBlocking();
+                _ptrRtpSocket = NULL;
+                _lastError = kMulticastAddressInvalid;
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+void UdpTransportImpl::BuildSockaddrIn(uint16_t portnr,
+                                       const char* ip,
+                                       SocketAddress& remoteAddr) const
+{
+    if(_ipV6Enabled)
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        remoteAddr.sin_length = 0;
+        remoteAddr.sin_family = PF_INET6;
+#else
+        remoteAddr._sockaddr_storage.sin_family = PF_INET6;
+#endif
+        remoteAddr._sockaddr_in6.sin6_port = Htons(portnr);
+        InetPresentationToNumeric(AF_INET6, ip,
+                                  &remoteAddr._sockaddr_in6.sin6_addr);
+        remoteAddr._sockaddr_in6.sin6_flowinfo=0;
+        remoteAddr._sockaddr_in6.sin6_scope_id=0;
+    } else
+    {
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        remoteAddr.sin_length = 0;
+        remoteAddr.sin_family = PF_INET;
+#else
+        remoteAddr._sockaddr_storage.sin_family = PF_INET;
+#endif
+        remoteAddr._sockaddr_in.sin_port = Htons(portnr);
+        remoteAddr._sockaddr_in.sin_addr= InetAddrIPV4(
+            const_cast<char*>(ip));
+    }
+}
+
+int32_t UdpTransportImpl::SendRaw(const int8_t *data,
+                                  size_t length,
+                                  int32_t isRTCP,
+                                  uint16_t portnr,
+                                  const char* ip)
+{
+    CriticalSectionScoped cs(_crit);
+    if(isRTCP)
+    {
+        UdpSocketWrapper* rtcpSock = NULL;
+        if(_ptrSendRtcpSocket)
+        {
+            rtcpSock = _ptrSendRtcpSocket;
+        } else if(_ptrRtcpSocket)
+        {
+            rtcpSock = _ptrRtcpSocket;
+        } else
+        {
+            return -1;
+        }
+        if(portnr == 0 && ip == NULL)
+        {
+            return rtcpSock->SendTo(data,length,_remoteRTCPAddr);
+
+        } else if(portnr != 0 && ip != NULL)
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(portnr, ip, remoteAddr);
+            return rtcpSock->SendTo(data,length,remoteAddr);
+        } else if(ip != NULL)
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(_destPortRTCP, ip, remoteAddr);
+            return rtcpSock->SendTo(data,length,remoteAddr);
+        } else
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(portnr, _destIP, remoteAddr);
+            return rtcpSock->SendTo(data,length,remoteAddr);
+        }
+    } else {
+        UdpSocketWrapper* rtpSock = NULL;
+        if(_ptrSendRtpSocket)
+        {
+            rtpSock = _ptrSendRtpSocket;
+
+        } else if(_ptrRtpSocket)
+        {
+            rtpSock = _ptrRtpSocket;
+        } else
+        {
+            return -1;
+        }
+        if(portnr == 0 && ip == NULL)
+        {
+            return rtpSock->SendTo(data,length,_remoteRTPAddr);
+
+        } else if(portnr != 0 && ip != NULL)
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(portnr, ip, remoteAddr);
+            return rtpSock->SendTo(data,length,remoteAddr);
+        } else if(ip != NULL)
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(_destPort, ip, remoteAddr);
+            return rtpSock->SendTo(data,length,remoteAddr);
+        } else
+        {
+            SocketAddress remoteAddr;
+            BuildSockaddrIn(portnr, _destIP, remoteAddr);
+            return rtpSock->SendTo(data,length,remoteAddr);
+        }
+    }
+}
+
+int32_t UdpTransportImpl::SendRTPPacketTo(const int8_t* data,
+                                          size_t length,
+                                          const SocketAddress& to)
+{
+    CriticalSectionScoped cs(_crit);
+    if(_ptrSendRtpSocket)
+    {
+        return _ptrSendRtpSocket->SendTo(data,length,to);
+
+    } else if(_ptrRtpSocket)
+    {
+        return _ptrRtpSocket->SendTo(data,length,to);
+    }
+    return -1;
+}
+
+int32_t UdpTransportImpl::SendRTCPPacketTo(const int8_t* data,
+                                           size_t length,
+                                           const SocketAddress& to)
+{
+
+    CriticalSectionScoped cs(_crit);
+
+    if(_ptrSendRtcpSocket)
+    {
+        return _ptrSendRtcpSocket->SendTo(data,length,to);
+
+    } else if(_ptrRtcpSocket)
+    {
+        return _ptrRtcpSocket->SendTo(data,length,to);
+    }
+    return -1;
+}
+
+int32_t UdpTransportImpl::SendRTPPacketTo(const int8_t* data,
+                                          size_t length,
+                                          const uint16_t rtpPort)
+{
+    CriticalSectionScoped cs(_crit);
+    // Use the current SocketAdress but update it with rtpPort.
+    SocketAddress to;
+    memcpy(&to, &_remoteRTPAddr, sizeof(SocketAddress));
+
+    if(_ipV6Enabled)
+    {
+        to._sockaddr_in6.sin6_port = Htons(rtpPort);
+    } else
+    {
+        to._sockaddr_in.sin_port = Htons(rtpPort);
+    }
+
+    if(_ptrSendRtpSocket)
+    {
+        return _ptrSendRtpSocket->SendTo(data,length,to);
+
+    } else if(_ptrRtpSocket)
+    {
+        return _ptrRtpSocket->SendTo(data,length,to);
+    }
+    return -1;
+}
+
+int32_t UdpTransportImpl::SendRTCPPacketTo(const int8_t* data,
+                                           size_t length,
+                                           const uint16_t rtcpPort)
+{
+    CriticalSectionScoped cs(_crit);
+
+    // Use the current SocketAdress but update it with rtcpPort.
+    SocketAddress to;
+    memcpy(&to, &_remoteRTCPAddr, sizeof(SocketAddress));
+
+    if(_ipV6Enabled)
+    {
+        to._sockaddr_in6.sin6_port = Htons(rtcpPort);
+    } else
+    {
+        to._sockaddr_in.sin_port = Htons(rtcpPort);
+    }
+
+    if(_ptrSendRtcpSocket)
+    {
+        return _ptrSendRtcpSocket->SendTo(data,length,to);
+
+    } else if(_ptrRtcpSocket)
+    {
+        return _ptrRtcpSocket->SendTo(data,length,to);
+    }
+    return -1;
+}
+
+bool UdpTransportImpl::SendRtp(const uint8_t* data,
+                               size_t length,
+                               const PacketOptions& packet_options) {
+    WEBRTC_TRACE(kTraceStream, kTraceTransport, _id, "%s", __FUNCTION__);
+
+    CriticalSectionScoped cs(_crit);
+
+    if(_destIP[0] == 0)
+    {
+        return false;
+    }
+    if(_destPort == 0)
+    {
+        return false;
+    }
+
+    // Create socket if it hasn't been set up already.
+    // TODO (hellner): why not fail here instead. Sockets not being initialized
+    //                 indicates that there is a problem somewhere.
+    if( _ptrSendRtpSocket == NULL &&
+        _ptrRtpSocket == NULL)
+    {
+        WEBRTC_TRACE(
+            kTraceStateInfo,
+            kTraceTransport,
+            _id,
+            "Creating RTP socket since no receive or source socket is\
+ configured");
+
+        _ptrRtpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
+                                        IncomingRTPCallback,
+                                        IpV6Enabled(), false);
+
+        // Don't bind to a specific IP address.
+        if(! IpV6Enabled())
+        {
+            strncpy(_localIP, "0.0.0.0",16);
+        } else
+        {
+            strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
+                    kIpAddressVersion6Length);
+        }
+        _localPort = _destPort;
+
+        ErrorCode retVal = BindLocalRTPSocket();
+        if(retVal != kNoSocketError)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "SendPacket() failed to bind RTP socket");
+            _lastError = retVal;
+            CloseReceiveSockets();
+            return false;
+        }
+    }
+
+    if(_ptrSendRtpSocket)
+    {
+        return _ptrSendRtpSocket->SendTo((const int8_t*)data, length,
+                                         _remoteRTPAddr) >= 0;
+
+    } else if(_ptrRtpSocket)
+    {
+        return _ptrRtpSocket->SendTo((const int8_t*)data, length,
+                                     _remoteRTPAddr) >= 0;
+    }
+    return false;
+}
+
+bool UdpTransportImpl::SendRtcp(const uint8_t* data, size_t length) {
+    CriticalSectionScoped cs(_crit);
+    if(_destIP[0] == 0)
+    {
+        return false;
+    }
+    if(_destPortRTCP == 0)
+    {
+        return false;
+    }
+
+    // Create socket if it hasn't been set up already.
+    // TODO (hellner): why not fail here instead. Sockets not being initialized
+    //                 indicates that there is a problem somewhere.
+    if( _ptrSendRtcpSocket == NULL &&
+        _ptrRtcpSocket == NULL)
+    {
+        WEBRTC_TRACE(
+            kTraceStateInfo,
+            kTraceTransport,
+            _id,
+            "Creating RTCP socket since no receive or source socket is\
+ configured");
+
+        _ptrRtcpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
+                                         IncomingRTCPCallback,
+                                         IpV6Enabled(), false);
+
+        // Don't bind to a specific IP address.
+        if(! IpV6Enabled())
+        {
+            strncpy(_localIP, "0.0.0.0",16);
+        } else
+        {
+            strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
+                    kIpAddressVersion6Length);
+        }
+        _localPortRTCP = _destPortRTCP;
+
+        ErrorCode retVal = BindLocalRTCPSocket();
+        if(retVal != kNoSocketError)
+        {
+            _lastError = retVal;
+            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                         "SendRtcp() failed to bind RTCP socket");
+            CloseReceiveSockets();
+            return false;
+        }
+    }
+
+    if(_ptrSendRtcpSocket)
+    {
+        return _ptrSendRtcpSocket->SendTo((const int8_t*)data, length,
+                                          _remoteRTCPAddr) >= 0;
+    } else if(_ptrRtcpSocket)
+    {
+        return _ptrRtcpSocket->SendTo((const int8_t*)data, length,
+                                      _remoteRTCPAddr) >= 0;
+    }
+    return false;
+}
+
+int32_t UdpTransportImpl::SetSendIP(const char* ipaddr)
+{
+    if(!IsIpAddressValid(ipaddr,IpV6Enabled()))
+    {
+        return kIpAddressInvalid;
+    }
+    CriticalSectionScoped cs(_crit);
+    strncpy(_destIP, ipaddr,kIpAddressVersion6Length);
+    BuildRemoteRTPAddr();
+    BuildRemoteRTCPAddr();
+    return 0;
+}
+
+int32_t UdpTransportImpl::SetSendPorts(uint16_t rtpPort, uint16_t rtcpPort)
+{
+    CriticalSectionScoped cs(_crit);
+    _destPort = rtpPort;
+    if(rtcpPort == 0)
+    {
+        _destPortRTCP = _destPort+1;
+    } else
+    {
+        _destPortRTCP = rtcpPort;
+    }
+    BuildRemoteRTPAddr();
+    BuildRemoteRTCPAddr();
+    return 0;
+}
+
+void UdpTransportImpl::IncomingRTPCallback(CallbackObj obj,
+                                           const int8_t* rtpPacket,
+                                           size_t rtpPacketLength,
+                                           const SocketAddress* from)
+{
+    if (rtpPacket && rtpPacketLength > 0)
+    {
+        UdpTransportImpl* socketTransport = (UdpTransportImpl*) obj;
+        socketTransport->IncomingRTPFunction(rtpPacket, rtpPacketLength, from);
+    }
+}
+
+void UdpTransportImpl::IncomingRTCPCallback(CallbackObj obj,
+                                            const int8_t* rtcpPacket,
+                                            size_t rtcpPacketLength,
+                                            const SocketAddress* from)
+{
+    if (rtcpPacket && rtcpPacketLength > 0)
+    {
+        UdpTransportImpl* socketTransport = (UdpTransportImpl*) obj;
+        socketTransport->IncomingRTCPFunction(rtcpPacket, rtcpPacketLength,
+                                              from);
+    }
+}
+
+void UdpTransportImpl::IncomingRTPFunction(const int8_t* rtpPacket,
+                                           size_t rtpPacketLength,
+                                           const SocketAddress* fromSocket)
+{
+    char ipAddress[kIpAddressVersion6Length];
+    uint32_t ipAddressLength = kIpAddressVersion6Length;
+    uint16_t portNr = 0;
+
+    {
+        CriticalSectionScoped cs(_critFilter);
+        if (FilterIPAddress(fromSocket) == false)
+        {
+            // Packet should be filtered out. Drop it.
+            WEBRTC_TRACE(kTraceStream, kTraceTransport, _id,
+                         "Incoming RTP packet blocked by IP filter");
+            return;
+        }
+
+        if (IPAddressCached(*fromSocket, ipAddress, ipAddressLength, portNr) <
+            0)
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "UdpTransportImpl::IncomingRTPFunction - Cannot get sender\
+ information");
+        }else
+        {
+            // Make sure ipAddress is null terminated.
+            ipAddress[kIpAddressVersion6Length - 1] = 0;
+            strncpy(_fromIP, ipAddress, kIpAddressVersion6Length - 1);
+        }
+
+        // Filter based on port.
+        if (_rtpFilterPort != 0 &&
+            _rtpFilterPort != portNr)
+        {
+            // Drop packet.
+            memset(_fromIP, 0, sizeof(_fromIP));
+            WEBRTC_TRACE(
+                kTraceStream,
+                kTraceTransport,
+                _id,
+                "Incoming RTP packet blocked by filter incoming from port:%d\
+ allowed port:%d",
+                portNr,
+                _rtpFilterPort);
+            return;
+        }
+        _fromPort = portNr;
+    }
+
+    CriticalSectionScoped cs(_critPacketCallback);
+    if (_packetCallback)
+    {
+        WEBRTC_TRACE(kTraceStream, kTraceTransport, _id,
+            "Incoming RTP packet from ip:%s port:%d", ipAddress, portNr);
+        _packetCallback->IncomingRTPPacket(rtpPacket, rtpPacketLength,
+                                           ipAddress, portNr);
+    }
+}
+
+void UdpTransportImpl::IncomingRTCPFunction(const int8_t* rtcpPacket,
+                                            size_t rtcpPacketLength,
+                                            const SocketAddress* fromSocket)
+{
+    char ipAddress[kIpAddressVersion6Length];
+    uint32_t ipAddressLength = kIpAddressVersion6Length;
+    uint16_t portNr = 0;
+
+    {
+        CriticalSectionScoped cs(_critFilter);
+        if (FilterIPAddress(fromSocket) == false)
+        {
+            // Packet should be filtered out. Drop it.
+            WEBRTC_TRACE(kTraceStream, kTraceTransport, _id,
+                         "Incoming RTCP packet blocked by IP filter");
+            return;
+        }
+        if (IPAddress(*fromSocket, ipAddress, ipAddressLength, portNr) < 0)
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "UdpTransportImpl::IncomingRTCPFunction - Cannot get sender\
+ information");
+        }else {
+            // Make sure ipAddress is null terminated.
+            ipAddress[kIpAddressVersion6Length - 1] = 0;
+            strncpy(_fromIP, ipAddress, kIpAddressVersion6Length - 1);
+        }
+
+        // Filter based on port.
+        if (_rtcpFilterPort != 0 &&
+            _rtcpFilterPort != portNr)
+        {
+            // Drop packet.
+            WEBRTC_TRACE(
+                kTraceStream,
+                kTraceTransport,
+                _id,
+                "Incoming RTCP packet blocked by filter incoming from port:%d\
+ allowed port:%d",
+                portNr,
+                _rtpFilterPort);
+            return;
+        }
+        _fromPortRTCP = portNr;
+    }
+
+    CriticalSectionScoped cs(_critPacketCallback);
+    if (_packetCallback)
+    {
+        WEBRTC_TRACE(kTraceStream, kTraceTransport, _id,
+                     "Incoming RTCP packet from ip:%s port:%d", ipAddress,
+                     portNr);
+        _packetCallback->IncomingRTCPPacket(rtcpPacket, rtcpPacketLength,
+                                            ipAddress, portNr);
+    }
+}
+
+bool UdpTransportImpl::FilterIPAddress(const SocketAddress* fromAddress)
+{
+    if(fromAddress->_sockaddr_storage.sin_family == AF_INET)
+    {
+        if (_filterIPAddress._sockaddr_storage.sin_family == AF_INET)
+        {
+            // IP is stored in sin_addr.
+            if (_filterIPAddress._sockaddr_in.sin_addr != 0 &&
+                (_filterIPAddress._sockaddr_in.sin_addr !=
+                 fromAddress->_sockaddr_in.sin_addr))
+            {
+                return false;
+            }
+        }
+    }
+    else if(fromAddress->_sockaddr_storage.sin_family == AF_INET6)
+    {
+        if (_filterIPAddress._sockaddr_storage.sin_family == AF_INET6)
+        {
+            // IP is stored in sin_6addr.
+            for (int32_t i = 0; i < 4; i++)
+            {
+                if (_filterIPAddress._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[i] != 0 &&
+                    _filterIPAddress._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[i] != fromAddress->_sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u32[i])
+                {
+                    return false;
+                }
+            }
+        }
+    }
+    else
+    {
+      WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                _id,
+                "UdpTransportImpl::FilterIPAddress() unknown address family");
+        return false;
+    }
+    return true;
+}
+
+void UdpTransportImpl::CloseReceiveSockets()
+{
+    if(_ptrRtpSocket)
+    {
+        _ptrRtpSocket->CloseBlocking();
+        _ptrRtpSocket = NULL;
+    }
+    if(_ptrRtcpSocket)
+    {
+        _ptrRtcpSocket->CloseBlocking();
+        _ptrRtcpSocket = NULL;
+    }
+    _receiving = false;
+}
+
+void UdpTransportImpl::CloseSendSockets()
+{
+    if(_ptrSendRtpSocket)
+    {
+        _ptrSendRtpSocket->CloseBlocking();
+        _ptrSendRtpSocket = 0;
+    }
+    if(_ptrSendRtcpSocket)
+    {
+        _ptrSendRtcpSocket->CloseBlocking();
+        _ptrSendRtcpSocket = 0;
+    }
+}
+
+uint16_t UdpTransport::Htons(const uint16_t port)
+{
+    return htons(port);
+}
+
+uint32_t UdpTransport::Htonl(const uint32_t a)
+{
+    return htonl(a);
+}
+
+uint32_t UdpTransport::InetAddrIPV4(const char* ip)
+{
+    return ::inet_addr(ip);
+}
+
+int32_t UdpTransport::InetPresentationToNumeric(int32_t af,
+                                                const char* src,
+                                                void* dst)
+{
+#if defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+    const int32_t result = inet_pton(af, src, dst);
+    return result > 0 ? 0 : -1;
+
+#elif defined(_WIN32)
+    SocketAddress temp;
+    int length=sizeof(SocketAddress);
+
+    if(af == AF_INET)
+    {
+        int32_t result = WSAStringToAddressA(
+            (const LPSTR)src,
+            af,
+            0,
+            reinterpret_cast<struct sockaddr*>(&temp),
+            &length);
+        if(result != 0)
+        {
+            return -1;
+        }
+        memcpy(dst,&(temp._sockaddr_in.sin_addr),
+               sizeof(temp._sockaddr_in.sin_addr));
+        return 0;
+    }
+    else if(af == AF_INET6)
+    {
+        int32_t result = WSAStringToAddressA(
+            (const LPSTR)src,
+            af,
+            0,
+            reinterpret_cast<struct sockaddr*>(&temp),
+            &length);
+        if(result !=0)
+        {
+            return -1;
+        }
+        memcpy(dst,&(temp._sockaddr_in6.sin6_addr),
+               sizeof(temp._sockaddr_in6.sin6_addr));
+        return 0;
+
+    }else
+    {
+        return -1;
+    }
+#else
+    return -1;
+#endif
+}
+
+int32_t UdpTransport::LocalHostAddressIPV6(char n_localIP[16])
+{
+
+#if defined(_WIN32)
+    struct addrinfo *result = NULL;
+    struct addrinfo *ptr = NULL;
+    struct addrinfo hints;
+
+    ZeroMemory(&hints, sizeof(hints));
+    hints.ai_family = AF_INET6;
+
+    char szHostName[256] = "";
+    if(::gethostname(szHostName, sizeof(szHostName) - 1))
+    {
+        WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1, "gethostname failed");
+        return -1;
+    }
+
+    DWORD dwRetval = getaddrinfo(szHostName, NULL, &hints, &result);
+    if ( dwRetval != 0 )
+    {
+        WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1,
+                     "getaddrinfo failed, error:%d", dwRetval);
+        return -1;
+    }
+    for(ptr=result; ptr != NULL ;ptr=ptr->ai_next)
+    {
+        switch (ptr->ai_family)
+        {
+            case AF_INET6:
+                {
+                    for(int i = 0; i< 16; i++)
+                    {
+                        n_localIP[i] = (*(SocketAddress*)ptr->ai_addr).
+                            _sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u8[i];
+                    }
+                    bool islocalIP = true;
+
+                    for(int n = 0; n< 15; n++)
+                    {
+                        if(n_localIP[n] != 0)
+                        {
+                            islocalIP = false;
+                            break;
+                        }
+                    }
+
+                    if(islocalIP && n_localIP[15] != 1)
+                    {
+                        islocalIP = false;
+                    }
+
+                    if(islocalIP && ptr->ai_next)
+                    {
+                        continue;
+                    }
+                    if(n_localIP[0] == 0xfe &&
+                       n_localIP[1] == 0x80 && ptr->ai_next)
+                    {
+                        continue;
+                    }
+                    freeaddrinfo(result);
+                }
+                return 0;
+            default:
+                break;
+        };
+    }
+    freeaddrinfo(result);
+    WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1,
+                 "getaddrinfo failed to find address");
+    return -1;
+
+#elif defined(WEBRTC_MAC)
+    struct ifaddrs* ptrIfAddrs = NULL;
+    struct ifaddrs* ptrIfAddrsStart = NULL;
+
+    getifaddrs(&ptrIfAddrsStart);
+    ptrIfAddrs = ptrIfAddrsStart;
+    while(ptrIfAddrs)
+    {
+        if(ptrIfAddrs->ifa_addr->sa_family == AF_INET6)
+        {
+            const struct sockaddr_in6* sock_in6 =
+                reinterpret_cast<struct sockaddr_in6*>(ptrIfAddrs->ifa_addr);
+            const struct in6_addr* sin6_addr = &sock_in6->sin6_addr;
+
+            if (IN6_IS_ADDR_LOOPBACK(sin6_addr) ||
+                IN6_IS_ADDR_LINKLOCAL(sin6_addr)) {
+                ptrIfAddrs = ptrIfAddrs->ifa_next;
+                continue;
+            }
+            memcpy(n_localIP, sin6_addr->s6_addr, sizeof(sin6_addr->s6_addr));
+            freeifaddrs(ptrIfAddrsStart);
+            return 0;
+        }
+        ptrIfAddrs = ptrIfAddrs->ifa_next;
+    }
+    freeifaddrs(ptrIfAddrsStart);
+    return -1;
+#elif defined(WEBRTC_ANDROID)
+    return -1;
+#else // WEBRTC_LINUX
+    struct
+    {
+        struct nlmsghdr n;
+        struct ifaddrmsg r;
+    } req;
+
+    struct rtattr* rta = NULL;
+    int status;
+    char buf[16384]; // = 16 * 1024 (16 kB)
+    struct nlmsghdr* nlmp;
+    struct ifaddrmsg* rtmp;
+    struct rtattr* rtatp;
+    int rtattrlen;
+    struct in6_addr* in6p;
+
+    int fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
+    if (fd == -1)
+    {
+        return -1;
+    }
+
+    // RTM_GETADDR is used to fetch the ip address from the kernel interface
+    // table. Populate the msg structure (req) the size of the message buffer
+    // is specified to netlinkmessage header, and flags values are set as
+    // NLM_F_ROOT | NLM_F_REQUEST.
+    // The request flag must be set for all messages requesting the data from
+    // kernel. The root flag is used to notify the kernel to return the full
+    // tabel. Another flag (not used) is NLM_F_MATCH. This is used to get only
+    // specified entries in the table. At the time of writing this program this
+    // flag is not implemented in kernel
+
+    memset(&req, 0, sizeof(req));
+    req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
+    req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
+    req.n.nlmsg_type = RTM_GETADDR;
+    req.r.ifa_family = AF_INET6;
+
+    // Fill up all the attributes for the rtnetlink header.
+    // The lenght is very important. 16 signifies the ipv6 address.
+    rta = (struct rtattr*)(((char*)&req) + NLMSG_ALIGN(req.n.nlmsg_len));
+    rta->rta_len = RTA_LENGTH(16);
+
+    status = send(fd, &req, req.n.nlmsg_len, 0);
+    if (status < 0)
+    {
+        close(fd);
+        return -1;
+    }
+    status = recv(fd, buf, sizeof(buf), 0);
+    if (status < 0)
+    {
+        close(fd);
+        return -1;
+    }
+    if(status == 0)
+    {
+        close(fd);
+        return -1;
+    }
+    close(fd);
+
+    // The message is stored in buff. Parse the message to get the requested
+    // data.
+    {
+        nlmp = (struct nlmsghdr*)buf;
+        int len = nlmp->nlmsg_len;
+        int req_len = len - sizeof(*nlmp);
+
+        if (req_len < 0 || len > status)
+        {
+            return -1;
+        }
+        if (!NLMSG_OK_NO_WARNING(nlmp, status))
+        {
+            return -1;
+        }
+        rtmp = (struct ifaddrmsg*)NLMSG_DATA(nlmp);
+        rtatp = (struct rtattr*)IFA_RTA(rtmp);
+
+        rtattrlen = IFA_PAYLOAD(nlmp);
+
+        for (; RTA_OK(rtatp, rtattrlen); rtatp = RTA_NEXT(rtatp, rtattrlen))
+        {
+
+            // Here we hit the fist chunk of the message. Time to validate the
+            // type. For more info on the different types see
+            // "man(7) rtnetlink" The table below is taken from man pages.
+            // Attributes
+            // rta_type        value type             description
+            // -------------------------------------------------------------
+            // IFA_UNSPEC      -                      unspecified.
+            // IFA_ADDRESS     raw protocol address   interface address
+            // IFA_LOCAL       raw protocol address   local address
+            // IFA_LABEL       asciiz string          name of the interface
+            // IFA_BROADCAST   raw protocol address   broadcast address.
+            // IFA_ANYCAST     raw protocol address   anycast address
+            // IFA_CACHEINFO   struct ifa_cacheinfo   Address information.
+
+            if(rtatp->rta_type == IFA_ADDRESS)
+            {
+                bool islocalIP = true;
+                in6p = (struct in6_addr*)RTA_DATA(rtatp);
+                for(int n = 0; n< 15; n++)
+                {
+                    if(in6p->s6_addr[n] != 0)
+                    {
+                        islocalIP = false;
+                        break;
+                    }
+                }
+                if(islocalIP && in6p->s6_addr[15] != 1)
+                {
+                    islocalIP = false;
+                }
+                if(!islocalIP)
+                {
+                    for(int i = 0; i< 16; i++)
+                    {
+                        n_localIP[i] = in6p->s6_addr[i];
+                    }
+                    if(n_localIP[0] == static_cast<char> (0xfe)
+                       && n_localIP[1] == static_cast<char>(0x80) )
+                    {
+                        // Auto configured IP.
+                        continue;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return 0;
+#endif
+}
+
+int32_t UdpTransport::LocalHostAddress(uint32_t& localIP)
+{
+ #if defined(_WIN32)
+    hostent* localHost;
+    localHost = gethostbyname( "" );
+    if(localHost)
+    {
+        if(localHost->h_addrtype != AF_INET)
+        {
+            WEBRTC_TRACE(
+                kTraceError,
+                kTraceTransport,
+                -1,
+                "LocalHostAddress can only get local IP for IP Version 4");
+            return -1;
+        }
+        localIP= Htonl(
+            (*(struct in_addr *)localHost->h_addr_list[0]).S_un.S_addr);
+        return 0;
+    }
+    else
+    {
+        int32_t error = WSAGetLastError();
+        WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1,
+                     "gethostbyname failed, error:%d", error);
+        return -1;
+    }
+#elif (defined(WEBRTC_MAC))
+    char localname[255];
+    if (gethostname(localname, 255) != -1)
+    {
+        hostent* localHost;
+        localHost = gethostbyname(localname);
+        if(localHost)
+        {
+            if(localHost->h_addrtype != AF_INET)
+            {
+                WEBRTC_TRACE(
+                    kTraceError,
+                    kTraceTransport,
+                    -1,
+                    "LocalHostAddress can only get local IP for IP Version 4");
+                return -1;
+            }
+            localIP = Htonl((*(struct in_addr*)*localHost->h_addr_list).s_addr);
+            return 0;
+        }
+    }
+    WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1, "gethostname failed");
+    return -1;
+#else // WEBRTC_LINUX
+    int sockfd, size  = 1;
+    struct ifreq* ifr;
+    struct ifconf ifc;
+
+    if (0 > (sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)))
+    {
+      return -1;
+    }
+    ifc.ifc_len = IFRSIZE;
+    ifc.ifc_req = NULL;
+    do
+    {
+        ++size;
+        // Buffer size needed is unknown. Try increasing it until no overflow
+        // occurs.
+        if (NULL == (ifc.ifc_req = (ifreq*)realloc(ifc.ifc_req, IFRSIZE))) {
+          fprintf(stderr, "Out of memory.\n");
+          exit(EXIT_FAILURE);
+        }
+        ifc.ifc_len = IFRSIZE;
+        if (ioctl(sockfd, SIOCGIFCONF, &ifc))
+        {
+            free(ifc.ifc_req);
+            close(sockfd);
+            return -1;
+        }
+    } while  (IFRSIZE <= ifc.ifc_len);
+
+    ifr = ifc.ifc_req;
+    for (;(char *) ifr < (char *) ifc.ifc_req + ifc.ifc_len; ++ifr)
+    {
+        if (ifr->ifr_addr.sa_data == (ifr+1)->ifr_addr.sa_data)
+        {
+          continue;  // duplicate, skip it
+        }
+        if (ioctl(sockfd, SIOCGIFFLAGS, ifr))
+        {
+          continue;  // failed to get flags, skip it
+        }
+        if(strncmp(ifr->ifr_name, "lo",3) == 0)
+        {
+            continue;
+        }else
+        {
+            struct sockaddr* saddr = &(ifr->ifr_addr);
+            SocketAddress* socket_addess = reinterpret_cast<SocketAddress*>(
+                saddr);
+            localIP = Htonl(socket_addess->_sockaddr_in.sin_addr);
+            close(sockfd);
+            free(ifc.ifc_req);
+            return 0;
+        }
+    }
+    free(ifc.ifc_req);
+    close(sockfd);
+    return -1;
+#endif
+}
+
+int32_t UdpTransport::IPAddress(const SocketAddress& address,
+                                char* ip,
+                                uint32_t& ipSize,
+                                uint16_t& sourcePort)
+{
+ #if defined(_WIN32)
+    DWORD dwIPSize = ipSize;
+    int32_t returnvalue = WSAAddressToStringA((LPSOCKADDR)(&address),
+                                         sizeof(SocketAddress),
+                                         NULL,
+                                         ip,
+                                         &dwIPSize);
+    if(returnvalue == -1)
+    {
+        return -1;
+    }
+
+    uint16_t source_port = 0;
+    if(address._sockaddr_storage.sin_family == AF_INET)
+    {
+        // Parse IP assuming format "a.b.c.d:port".
+        char* ipEnd = strchr(ip,':');
+        if(ipEnd != NULL)
+        {
+            *ipEnd = '\0';
+        }
+        ipSize = (int32_t)strlen(ip);
+        if(ipSize == 0)
+        {
+            return -1;
+        }
+        source_port = address._sockaddr_in.sin_port;
+    }
+    else
+    {
+        // Parse IP assuming format "[address]:port".
+        char* ipEnd = strchr(ip,']');
+        if(ipEnd != NULL)
+        {
+          // Calculate length
+            int32_t adrSize = int32_t(ipEnd - ip) - 1;
+            memmove(ip, &ip[1], adrSize);   // Remove '['
+            *(ipEnd - 1) = '\0';
+        }
+        ipSize = (int32_t)strlen(ip);
+        if(ipSize == 0)
+        {
+            return -1;
+        }
+
+        source_port = address._sockaddr_in6.sin6_port;
+    }
+    // Convert port number to network byte order.
+    sourcePort = htons(source_port);
+    return 0;
+
+ #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+    int32_t ipFamily = address._sockaddr_storage.sin_family;
+    const void* ptrNumericIP = NULL;
+
+    if(ipFamily == AF_INET)
+    {
+        ptrNumericIP = &(address._sockaddr_in.sin_addr);
+    }
+    else if(ipFamily == AF_INET6)
+    {
+        ptrNumericIP = &(address._sockaddr_in6.sin6_addr);
+    }
+    else
+    {
+        return -1;
+    }
+    if(inet_ntop(ipFamily, ptrNumericIP, ip, ipSize) == NULL)
+    {
+        return -1;
+    }
+    uint16_t source_port;
+    if(ipFamily == AF_INET)
+    {
+        source_port = address._sockaddr_in.sin_port;
+    } else
+    {
+        source_port = address._sockaddr_in6.sin6_port;
+    }
+    // Convert port number to network byte order.
+    sourcePort = htons(source_port);
+    return 0;
+ #else
+    return -1;
+ #endif
+}
+
+bool UdpTransport::IsIpAddressValid(const char* ipadr, const bool ipV6)
+{
+    if(ipV6)
+    {
+        int32_t len = (int32_t)strlen(ipadr);
+        if( len>39 || len == 0)
+        {
+            return false;
+        }
+
+        int32_t i;
+        int32_t colonPos[7] = {0,0,0,0,0,0,0};
+        int32_t lastColonPos = -2;
+        int32_t nColons = 0;
+        int32_t nDubbleColons = 0;
+        int32_t nDots = 0;
+        int32_t error = 0;
+        char c;
+        for(i = 0; i < len ; i++)
+        {
+            c=ipadr[i];
+            if(isxdigit(c))
+                ;
+            else if(c == ':')
+            {
+                if(nColons < 7)
+                    colonPos[nColons] = i;
+                if((i-lastColonPos)==1)
+                    nDubbleColons++;
+                lastColonPos=i;
+                if(nDots != 0)
+                {
+                    error = 1;
+                }
+                nColons++;
+            }
+            else if(c == '.')
+            {
+                nDots++;
+            }
+            else
+            {
+                error = 1;
+            }
+
+        }
+        if(error)
+        {
+            return false;
+        }
+        if(nDubbleColons > 1)
+        {
+            return false;
+        }
+        if(nColons > 7 || nColons < 2)
+        {
+            return false;
+        }
+        if(!(nDots == 3 || nDots == 0))
+        {
+            return false;
+        }
+        lastColonPos = -1;
+        int32_t charsBeforeColon = 0;
+        for(i = 0; i < nColons; i++)
+        {
+            charsBeforeColon=colonPos[i]-lastColonPos-1;
+            if(charsBeforeColon > 4)
+            {
+                return false;
+            }
+            lastColonPos=colonPos[i];
+        }
+        int32_t lengthAfterLastColon = len - lastColonPos - 1;
+        if(nDots == 0)
+        {
+            if(lengthAfterLastColon > 4)
+                return false;
+        }
+        if(nDots == 3 && lengthAfterLastColon > 0)
+        {
+            return IsIpAddressValid((ipadr+lastColonPos+1),false);
+        }
+
+    }
+    else
+    {
+        int32_t len = (int32_t)strlen(ipadr);
+        if((len>15)||(len==0))
+        {
+            return false;
+        }
+
+        // IPv4 should be [0-255].[0-255].[0-255].[0-255]
+        int32_t i;
+        int32_t nDots = 0;
+        int32_t iDotPos[4] = {0,0,0,0};
+
+        for (i = 0; (i < len) && (nDots < 4); i++)
+        {
+            if (ipadr[i] == (char)'.')
+            {
+                // Store index of dots and count number of dots.
+                iDotPos[nDots++] = i;
+            }
+            else if (isdigit(ipadr[i]) == 0)
+            {
+                return false;
+            }
+        }
+
+        bool allUnder256 = false;
+        // TODO (hellner): while loop seems to be abused here to get
+        // label like functionality. Fix later to avoid introducing bugs now.
+
+        // Check that all numbers are smaller than 256.
+        do
+        {
+            if (nDots != 3 )
+            {
+                break;
+            }
+
+            if (iDotPos[0] <= 3)
+            {
+                char nr[4];
+                memset(nr,0,4);
+                strncpy(nr,&ipadr[0],iDotPos[0]);
+                int32_t num = atoi(nr);
+                if (num > 255 || num < 0)
+                {
+                    break;
+                }
+            } else {
+                break;
+            }
+
+            if (iDotPos[1] - iDotPos[0] <= 4)
+            {
+                char nr[4];
+                memset(nr,0,4);
+                strncpy(nr,&ipadr[iDotPos[0]+1], iDotPos[1] - iDotPos[0] - 1);
+                int32_t num = atoi(nr);
+                if (num > 255 || num < 0)
+                    break;
+            } else {
+                break;
+            }
+
+            if (iDotPos[2] - iDotPos[1] <= 4)
+            {
+                char nr[4];
+                memset(nr,0,4);
+                strncpy(nr,&ipadr[iDotPos[1]+1], iDotPos[2] - iDotPos[1] - 1);
+                int32_t num = atoi(nr);
+                if (num > 255 || num < 0)
+                    break;
+            } else {
+                break;
+            }
+
+            if (len - iDotPos[2] <= 4)
+            {
+                char nr[4];
+                memset(nr,0,4);
+                strncpy(nr,&ipadr[iDotPos[2]+1], len - iDotPos[2] -1);
+                int32_t num = atoi(nr);
+                if (num > 255 || num < 0)
+                    break;
+                else
+                    allUnder256 = true;
+            } else {
+                break;
+            }
+        } while(false);
+
+        if (nDots != 3 || !allUnder256)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+}  // namespace test
+}  // namespace webrtc